diff --git a/libs/ui/KisPart.cpp b/libs/ui/KisPart.cpp
index 90a33f7047..bdd1bc6318 100644
--- a/libs/ui/KisPart.cpp
+++ b/libs/ui/KisPart.cpp
@@ -1,565 +1,565 @@
 /* This file is part of the KDE project
  * Copyright (C) 1998-1999 Torben Weis       <weis@kde.org>
  * Copyright (C) 2000-2005 David Faure       <faure@kde.org>
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010-2012 Boudewijn Rempt   <boud@valdyas.org>
  * Copyright (C) 2011 Inge Wallin            <ingwa@kogmbh.com>
  * Copyright (C) 2015 Michael Abrahams       <miabraha@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisPart.h"
 
 #include "KoProgressProxy.h"
 #include <KoCanvasController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoColorSpaceEngine.h>
 #include <KoCanvasBase.h>
 #include <KoToolManager.h>
 #include <KoShapeControllerBase.h>
 #include <KoResourceServerProvider.h>
 #include <kis_icon.h>
 
 #include "KisApplication.h"
 #include "KisMainWindow.h"
 #include "KisDocument.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "KisImportExportManager.h"
 
 #include <kis_debug.h>
 #include <KoResourcePaths.h>
 #include <KoDialog.h>
 #include <kdesktopfile.h>
 #include <QMessageBox>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <QKeySequence>
 
 #include <QDialog>
 #include <QApplication>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QGlobalStatic>
 #include <KisMimeDatabase.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "kis_config.h"
 #include "kis_shape_controller.h"
 #include "KisResourceServerProvider.h"
 #include "kis_animation_cache_populator.h"
 #include "kis_idle_watcher.h"
 #include "kis_image.h"
 #include "KisOpenPane.h"
 
 #include "kis_color_manager.h"
 
 #include "kis_action.h"
 #include "kis_action_registry.h"
 #include "KisSessionResource.h"
 
 Q_GLOBAL_STATIC(KisPart, s_instance)
 
 
 class Q_DECL_HIDDEN KisPart::Private
 {
 public:
     Private(KisPart *_part)
         : part(_part)
         , idleWatcher(2500)
         , animationCachePopulator(_part)
     {
     }
 
     ~Private()
     {
     }
 
     KisPart *part;
 
     QList<QPointer<KisView> > views;
     QList<QPointer<KisMainWindow> > mainWindows;
     QList<QPointer<KisDocument> > documents;
     KActionCollection *actionCollection{0};
     KisIdleWatcher idleWatcher;
     KisAnimationCachePopulator animationCachePopulator;
 
     KisSessionResource *currentSession = nullptr;
     bool closingSession{false};
     QScopedPointer<KisSessionManagerDialog> sessionManager;
 
     bool queryCloseDocument(KisDocument *document) {
         Q_FOREACH(auto view, views) {
             if (view && view->isVisible() && view->document() == document) {
                 return view->queryClose();
             }
         }
 
         return true;
     }
 };
 
 
 KisPart* KisPart::instance()
 {
     return s_instance;
 }
 
 
 KisPart::KisPart()
     : d(new Private(this))
 {
     // Preload all the resources in the background
     Q_UNUSED(KoResourceServerProvider::instance());
     Q_UNUSED(KisResourceServerProvider::instance());
     Q_UNUSED(KisColorManager::instance());
 
     connect(this, SIGNAL(documentOpened(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(this, SIGNAL(documentClosed(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(KisActionRegistry::instance(), SIGNAL(shortcutsUpdated()),
             this, SLOT(updateShortcuts()));
     connect(&d->idleWatcher, SIGNAL(startedIdleMode()),
             &d->animationCachePopulator, SLOT(slotRequestRegeneration()));
 
 
     d->animationCachePopulator.slotRequestRegeneration();
 }
 
 KisPart::~KisPart()
 {
     while (!d->documents.isEmpty()) {
         delete d->documents.takeFirst();
     }
 
     while (!d->views.isEmpty()) {
         delete d->views.takeFirst();
     }
 
     while (!d->mainWindows.isEmpty()) {
         delete d->mainWindows.takeFirst();
     }
 
     delete d;
 }
 
 void KisPart::updateIdleWatcherConnections()
 {
     QVector<KisImageSP> images;
 
     Q_FOREACH (QPointer<KisDocument> document, documents()) {
         if (document->image()) {
             images << document->image();
         }
     }
 
     d->idleWatcher.setTrackedImages(images);
 }
 
 void KisPart::addDocument(KisDocument *document)
 {
     //dbgUI << "Adding document to part list" << document;
     Q_ASSERT(document);
     if (!d->documents.contains(document)) {
         d->documents.append(document);
         emit documentOpened('/'+objectName());
         emit sigDocumentAdded(document);
         connect(document, SIGNAL(sigSavingFinished()), SLOT(slotDocumentSaved()));
     }
 }
 
 QList<QPointer<KisDocument> > KisPart::documents() const
 {
     return d->documents;
 }
 
 KisDocument *KisPart::createDocument() const
 {
     KisDocument *doc = new KisDocument();
     return doc;
 }
 
 
 int KisPart::documentCount() const
 {
     return d->documents.size();
 }
 
 void KisPart::removeDocument(KisDocument *document)
 {
     d->documents.removeAll(document);
     emit documentClosed('/'+objectName());
     emit sigDocumentRemoved(document->url().toLocalFile());
     document->deleteLater();
 }
 
 KisMainWindow *KisPart::createMainWindow(QUuid id)
 {
     KisMainWindow *mw = new KisMainWindow(id);
     dbgUI <<"mainWindow" << (void*)mw << "added to view" << this;
     d->mainWindows.append(mw);
     emit sigWindowAdded(mw);
     return mw;
 }
 
 KisView *KisPart::createView(KisDocument *document,
                              KoCanvasResourceProvider *resourceManager,
                              KActionCollection *actionCollection,
                              QWidget *parent)
 {
     // If creating the canvas fails, record this and disable OpenGL next time
     KisConfig cfg(false);
     KConfigGroup grp( KSharedConfig::openConfig(), "crashprevention");
     if (grp.readEntry("CreatingCanvas", false)) {
-        cfg.setUseOpenGL(false);
+        cfg.disableOpenGL();
     }
     if (cfg.canvasState() == "OPENGL_FAILED") {
-        cfg.setUseOpenGL(false);
+        cfg.disableOpenGL();
     }
     grp.writeEntry("CreatingCanvas", true);
     grp.sync();
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
     KisView *view  = new KisView(document, resourceManager, actionCollection, parent);
     QApplication::restoreOverrideCursor();
 
     // Record successful canvas creation
     grp.writeEntry("CreatingCanvas", false);
     grp.sync();
 
     addView(view);
 
     return view;
 }
 
 void KisPart::addView(KisView *view)
 {
     if (!view)
         return;
 
     if (!d->views.contains(view)) {
         d->views.append(view);
     }
 
     emit sigViewAdded(view);
 }
 
 void KisPart::removeView(KisView *view)
 {
     if (!view) return;
 
     /**
      * HACK ALERT: we check here explicitly if the document (or main
      *             window), is saving the stuff. If we close the
      *             document *before* the saving is completed, a crash
      *             will happen.
      */
     KIS_ASSERT_RECOVER_RETURN(!view->mainWindow()->hackIsSaving());
 
     emit sigViewRemoved(view);
 
     QPointer<KisDocument> doc = view->document();
     d->views.removeAll(view);
 
     if (doc) {
         bool found = false;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->document() == doc) {
                 found = true;
                 break;
             }
         }
         if (!found) {
             removeDocument(doc);
         }
     }
 }
 
 QList<QPointer<KisView> > KisPart::views() const
 {
     return d->views;
 }
 
 int KisPart::viewCount(KisDocument *doc) const
 {
     if (!doc) {
         return d->views.count();
     }
     else {
         int count = 0;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->isVisible() && view->document() == doc) {
                 count++;
             }
         }
         return count;
     }
 }
 
 bool KisPart::closingSession() const
 {
     return d->closingSession;
 }
 
 bool KisPart::closeSession(bool keepWindows)
 {
     d->closingSession = true;
 
     Q_FOREACH(auto document, d->documents) {
         if (!d->queryCloseDocument(document.data())) {
             d->closingSession = false;
             return false;
         }
     }
 
     if (d->currentSession) {
         KisConfig kisCfg(false);
         if (kisCfg.saveSessionOnQuit(false)) {
 
             d->currentSession->storeCurrentWindows();
             d->currentSession->save();
 
             KConfigGroup cfg = KSharedConfig::openConfig()->group("session");
             cfg.writeEntry("previousSession", d->currentSession->name());
         }
 
         d->currentSession = nullptr;
     }
 
     if (!keepWindows) {
         Q_FOREACH (auto window, d->mainWindows) {
             window->close();
         }
 
         if (d->sessionManager) {
             d->sessionManager->close();
         }
     }
 
     d->closingSession = false;
     return true;
 }
 
 void KisPart::slotDocumentSaved()
 {
     KisDocument *doc = qobject_cast<KisDocument*>(sender());
     emit sigDocumentSaved(doc->url().toLocalFile());
 }
 
 void KisPart::removeMainWindow(KisMainWindow *mainWindow)
 {
     dbgUI <<"mainWindow" << (void*)mainWindow <<"removed from doc" << this;
     if (mainWindow) {
         d->mainWindows.removeAll(mainWindow);
     }
 }
 
 const QList<QPointer<KisMainWindow> > &KisPart::mainWindows() const
 {
     return d->mainWindows;
 }
 
 int KisPart::mainwindowCount() const
 {
     return d->mainWindows.count();
 }
 
 
 KisMainWindow *KisPart::currentMainwindow() const
 {
     QWidget *widget = qApp->activeWindow();
     KisMainWindow *mainWindow = qobject_cast<KisMainWindow*>(widget);
     while (!mainWindow && widget) {
         widget = widget->parentWidget();
         mainWindow = qobject_cast<KisMainWindow*>(widget);
     }
 
     if (!mainWindow && mainWindows().size() > 0) {
         mainWindow = mainWindows().first();
     }
     return mainWindow;
 
 }
 
 KisMainWindow * KisPart::windowById(QUuid id) const
 {
     Q_FOREACH(QPointer<KisMainWindow> mainWindow, d->mainWindows) {
         if (mainWindow->id() == id) {
             return mainWindow;
         }
     }
 
     return nullptr;
 }
 
 KisIdleWatcher* KisPart::idleWatcher() const
 {
     return &d->idleWatcher;
 }
 
 KisAnimationCachePopulator* KisPart::cachePopulator() const
 {
     return &d->animationCachePopulator;
 }
 
 void KisPart::openExistingFile(const QUrl &url)
 {
     // TODO: refactor out this method!
 
     KisMainWindow *mw = currentMainwindow();
     KIS_SAFE_ASSERT_RECOVER_RETURN(mw);
 
     mw->openDocument(url, KisMainWindow::None);
 }
 
 void KisPart::updateShortcuts()
 {
     // Update any non-UI actionCollections.  That includes:
     // Now update the UI actions.
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         KActionCollection *ac = mainWindow->actionCollection();
 
         ac->updateShortcuts();
 
         // Loop through mainWindow->actionCollections() to modify tooltips
         // so that they list shortcuts at the end in parentheses
         Q_FOREACH ( QAction* action, ac->actions())
         {
             // Remove any existing suffixes from the tooltips.
             // Note this regexp starts with a space, e.g. " (Ctrl-a)"
             QString strippedTooltip = action->toolTip().remove(QRegExp("\\s\\(.*\\)"));
 
             // Now update the tooltips with the new shortcut info.
             if (action->shortcut() == QKeySequence(0))
                 action->setToolTip(strippedTooltip);
             else
                 action->setToolTip( strippedTooltip + " (" + action->shortcut().toString() + ")");
         }
     }
 }
 
 void KisPart::openTemplate(const QUrl &url)
 {
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument *document = createDocument();
 
     bool ok = document->loadNativeFormat(url.toLocalFile());
     document->setModified(false);
     document->undoStack()->clear();
 
     if (ok) {
         QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
         // in case this is a open document template remove the -template from the end
         mimeType.remove( QRegExp( "-template$" ) );
         document->setMimeTypeAfterLoading(mimeType);
         document->resetURL();
         document->setReadWrite(true);
     }
     else {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1", document->localFilePath()));
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         delete document;
         return;
     }
     addDocument(document);
 
     KisMainWindow *mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
 
     }
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::addRecentURLToAllMainWindows(QUrl url)
 {
     // Add to recent actions list in our mainWindows
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         mainWindow->addRecentURL(url);
     }
 }
 
 
 void KisPart::startCustomDocument(KisDocument* doc)
 {
     addDocument(doc);
     KisMainWindow *mw = currentMainwindow();
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
     mw->addViewAndNotifyLoadingCompleted(doc);
 
 }
 
 KisInputManager* KisPart::currentInputManager()
 {
     KisMainWindow *mw = currentMainwindow();
     KisViewManager *manager = mw ? mw->viewManager() : 0;
     return manager ? manager->inputManager() : 0;
 }
 
 void KisPart::showSessionManager()
 {
     if (d->sessionManager.isNull()) {
         d->sessionManager.reset(new KisSessionManagerDialog());
     }
 
     d->sessionManager->show();
     d->sessionManager->activateWindow();
 }
 
 void KisPart::startBlankSession()
 {
     KisMainWindow *window = createMainWindow();
     window->initializeGeometry();
     window->show();
 
 }
 
 bool KisPart::restoreSession(const QString &sessionName)
 {
     if (sessionName.isNull()) return false;
 
     KoResourceServer<KisSessionResource> * rserver = KisResourceServerProvider::instance()->sessionServer();
     auto *session = rserver->resourceByName(sessionName);
     if (!session || !session->valid()) return false;
 
     session->restore();
 
     return true;
 }
 
 void KisPart::setCurrentSession(KisSessionResource *session)
 {
     d->currentSession = session;
 }
diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index e1a8a17353..72a90fa2fe 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1738 +1,1740 @@
 /*
  *  preferencesdlg.cc - part of KImageShop
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_preferences.h"
 
 #include <config-hdr.h>
 #include <opengl/kis_opengl.h>
 
 #include <QBitmap>
 #include <QCheckBox>
 #include <QCursor>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QSlider>
 #include <QToolButton>
 #include <QThread>
 #include <QStandardPaths>
 #include <QGroupBox>
 #include <QGridLayout>
 #include <QRadioButton>
 #include <QGroupBox>
 #include <QMdiArea>
 #include <QMessageBox>
 #include <QDesktopWidget>
 #include <QFileDialog>
 #include <QFormLayout>
 #include <QSettings>
 
 #include <KisDocument.h>
 #include <KoColorProfile.h>
 #include <KisApplication.h>
 #include <KoFileDialog.h>
 #include <KisPart.h>
 #include <KoColorSpaceEngine.h>
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include "KoID.h"
 #include <KoConfigAuthorPage.h>
 #include <KoVBox.h>
 
 #include <klocalizedstring.h>
 #include <kformat.h>
 #include <kundo2stack.h>
 #include <KoResourcePaths.h>
 #include "kis_action_registry.h"
 #include <kis_image.h>
 #include <KisSqueezedComboBox.h>
 #include "kis_clipboard.h"
 #include "widgets/kis_cmb_idlist.h"
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorConversionTransformation.h"
 #include "kis_cursor.h"
 #include "kis_config.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_preference_set_registry.h"
 #include "kis_color_manager.h"
 #include "KisProofingConfiguration.h"
 #include "kis_image_config.h"
 
 #include "slider_and_spin_box_sync.h"
 
 // for the performance update
 #include <kis_cubic_curve.h>
 #include <kis_signals_blocker.h>
 
 #include "input/config/kis_input_configuration_page.h"
 #include "input/wintab/drawpile_tablettester/tablettester.h"
 
 #ifdef Q_OS_WIN
 #include "config_use_qt_tablet_windows.h"
 #   ifndef USE_QT_TABLET_WINDOWS
 #       include <kis_tablet_support_win8.h>
 #   endif
 #include "config-high-dpi-scale-factor-rounding-policy.h"
 #endif
 
 struct BackupSuffixValidator : public QValidator {
     BackupSuffixValidator(QObject *parent)
         : QValidator(parent)
         , invalidCharacters(QStringList()
                             << "0" << "1" << "2" << "3" << "4" << "5" << "6" << "7" << "8" << "9"
                             << "/" << "\\" << ":" << ";" << " ")
     {}
 
     ~BackupSuffixValidator() override {}
 
     const QStringList invalidCharacters;
 
     State validate(QString &line, int &/*pos*/) const override
     {
         Q_FOREACH(const QString invalidChar, invalidCharacters) {
             if (line.contains(invalidChar)) {
                 return Invalid;
             }
         }
         return Acceptable;
     }
 };
 
 
 GeneralTab::GeneralTab(QWidget *_parent, const char *_name)
     : WdgGeneralSettings(_parent, _name)
 {
     KisConfig cfg(true);
 
     //
     // Cursor Tab
     //
     m_cmbCursorShape->addItem(i18n("No Cursor"));
     m_cmbCursorShape->addItem(i18n("Tool Icon"));
     m_cmbCursorShape->addItem(i18n("Arrow"));
     m_cmbCursorShape->addItem(i18n("Small Circle"));
     m_cmbCursorShape->addItem(i18n("Crosshair"));
     m_cmbCursorShape->addItem(i18n("Triangle Righthanded"));
     m_cmbCursorShape->addItem(i18n("Triangle Lefthanded"));
     m_cmbCursorShape->addItem(i18n("Black Pixel"));
     m_cmbCursorShape->addItem(i18n("White Pixel"));
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle());
 
     m_cmbOutlineShape->addItem(i18n("No Outline"));
     m_cmbOutlineShape->addItem(i18n("Circle Outline"));
     m_cmbOutlineShape->addItem(i18n("Preview Outline"));
     m_cmbOutlineShape->addItem(i18n("Tilt Outline"));
 
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle());
 
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting());
     m_changeBrushOutline->setChecked(!cfg.forceAlwaysFullSizedOutline());
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor());
     cursorColorBtutton->setColor(cursorColor);
 
     //
     // Window Tab
     //
     m_cmbMDIType->setCurrentIndex(cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView));
 
     m_backgroundimage->setText(cfg.getMDIBackgroundImage());
     connect(m_bnFileName, SIGNAL(clicked()), SLOT(getBackgroundImage()));
     connect(clearBgImageButton, SIGNAL(clicked()), SLOT(clearBackgroundImage()));
 
     QString xml = cfg.getMDIBackgroundColor();
     KoColor mdiColor = KoColor::fromXML(xml);
     m_mdiColor->setColor(mdiColor);
 
     m_chkRubberBand->setChecked(cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages());
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     m_chkHiDPI->setChecked(kritarc.value("EnableHiDPI", true).toBool());
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
     m_chkHiDPIFractionalScaling->setChecked(kritarc.value("EnableHiDPIFractionalScaling", true).toBool());
 #else
     m_chkHiDPIFractionalScaling->setVisible(false);
 #endif
     chkUsageLogging->setChecked(kritarc.value("LogUsage", true).toBool());
     m_chkSingleApplication->setChecked(kritarc.value("EnableSingleApplication", true).toBool());
 
     //
     // Tools tab
     //
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker());
     cmbFlowMode->setCurrentIndex((int)!cfg.readEntry<bool>("useCreamyAlphaDarken", true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt());
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas());
     chkEnableTranformToolAfterPaste->setChecked(cfg.activateTransformToolAfterPaste());
 
     m_groupBoxKineticScrollingSettings->setChecked(cfg.kineticScrollingEnabled());
 
     m_cmbKineticScrollingGesture->addItem(i18n("On Touch Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Click Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Middle-Click Drag"));
     //m_cmbKineticScrollingGesture->addItem(i18n("On Right Click Drag"));
 
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture());
     m_kineticScrollingSensitivitySlider->setRange(0, 100);
     m_kineticScrollingSensitivitySlider->setValue(cfg.kineticScrollingSensitivity());
     m_chkKineticScrollingHideScrollbars->setChecked(cfg.kineticScrollingHiddenScrollbars());
 
     //
     // File handling
     //
     int autosaveInterval = cfg.autoSaveInterval();
     //convert to minutes
     m_autosaveSpinBox->setValue(autosaveInterval / 60);
     m_autosaveCheckBox->setChecked(autosaveInterval > 0);
     chkHideAutosaveFiles->setChecked(cfg.readEntry<bool>("autosavefileshidden", true));
 
     m_chkCompressKra->setChecked(cfg.compressKra());
     chkZip64->setChecked(cfg.useZip64());
 
     m_backupFileCheckBox->setChecked(cfg.backupFile());
     cmbBackupFileLocation->setCurrentIndex(cfg.readEntry<int>("backupfilelocation", 0));
     txtBackupFileSuffix->setText(cfg.readEntry<QString>("backupfilesuffix", "~"));
     QValidator *validator = new BackupSuffixValidator(txtBackupFileSuffix);
     txtBackupFileSuffix->setValidator(validator);
     intNumBackupFiles->setValue(cfg.readEntry<int>("numberofbackupfiles", 1));
 
     //
     // Miscellaneous
     //
     cmbStartupSession->addItem(i18n("Open default window"));
     cmbStartupSession->addItem(i18n("Load previous session"));
     cmbStartupSession->addItem(i18n("Show session manager"));
     cmbStartupSession->setCurrentIndex(cfg.sessionOnStartup());
 
     chkSaveSessionOnQuit->setChecked(cfg.saveSessionOnQuit(false));
 
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport());
 
     m_undoStackSize->setValue(cfg.undoStackLimit());
 
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets());
 
     chkShowRootLayer->setChecked(cfg.showRootLayer());
 
     KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
     bool dontUseNative = true;
 #ifdef Q_OS_UNIX
     if (qgetenv("XDG_CURRENT_DESKTOP") == "KDE") {
         dontUseNative = false;
     }
 #endif
 #ifdef Q_OS_WIN
     dontUseNative = false;
 #endif
     m_chkNativeFileDialog->setChecked(!group.readEntry("DontUseNativeFileDialog", dontUseNative));
 
     intMaxBrushSize->setValue(cfg.readEntry("maximumBrushSize", 1000));
 }
 
 void GeneralTab::setDefault()
 {
     KisConfig cfg(true);
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle(true));
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle(true));
     chkShowRootLayer->setChecked(cfg.showRootLayer(true));
     m_autosaveCheckBox->setChecked(cfg.autoSaveInterval(true) > 0);
     //convert to minutes
     m_autosaveSpinBox->setValue(cfg.autoSaveInterval(true) / 60);
     chkHideAutosaveFiles->setChecked(true);
 
     m_undoStackSize->setValue(cfg.undoStackLimit(true));
 
     m_backupFileCheckBox->setChecked(cfg.backupFile(true));
     cmbBackupFileLocation->setCurrentIndex(0);
     txtBackupFileSuffix->setText("~");
     intNumBackupFiles->setValue(1);
 
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting(true));
     m_changeBrushOutline->setChecked(!cfg.forceAlwaysFullSizedOutline(true));
 
     m_chkNativeFileDialog->setChecked(false);
     intMaxBrushSize->setValue(1000);
 
     m_cmbMDIType->setCurrentIndex((int)QMdiArea::TabbedView);
     m_chkRubberBand->setChecked(cfg.useOpenGL(true));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets(true));
     KoColor mdiColor;
     mdiColor.fromXML(cfg.getMDIBackgroundColor(true));
     m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage(true));
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages(true));
     m_chkCompressKra->setChecked(cfg.compressKra(true));
     chkZip64->setChecked(cfg.useZip64(true));
     m_chkHiDPI->setChecked(false);
     m_chkSingleApplication->setChecked(true);
 
     m_chkHiDPI->setChecked(true);
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
     m_chkHiDPIFractionalScaling->setChecked(true);
 #endif
     chkUsageLogging->setChecked(true);
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker(true));
     cmbFlowMode->setCurrentIndex(0);
     m_groupBoxKineticScrollingSettings->setChecked(cfg.kineticScrollingEnabled(true));
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture(true));
     m_kineticScrollingSensitivitySlider->setValue(cfg.kineticScrollingSensitivity(true));
     m_chkKineticScrollingHideScrollbars->setChecked(cfg.kineticScrollingHiddenScrollbars(true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt(true));
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas(true));
     chkEnableTranformToolAfterPaste->setChecked(cfg.activateTransformToolAfterPaste(true));
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport(true));
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor(true));
     cursorColorBtutton->setColor(cursorColor);
 
 
 
 }
 
 CursorStyle GeneralTab::cursorStyle()
 {
     return (CursorStyle)m_cmbCursorShape->currentIndex();
 }
 
 OutlineStyle GeneralTab::outlineStyle()
 {
     return (OutlineStyle)m_cmbOutlineShape->currentIndex();
 }
 
 KisConfig::SessionOnStartup GeneralTab::sessionOnStartup() const
 {
     return (KisConfig::SessionOnStartup)cmbStartupSession->currentIndex();
 }
 
 bool GeneralTab::saveSessionOnQuit() const
 {
     return chkSaveSessionOnQuit->isChecked();
 }
 
 bool GeneralTab::showRootLayer()
 {
     return chkShowRootLayer->isChecked();
 }
 
 int GeneralTab::autoSaveInterval()
 {
     //convert to seconds
     return m_autosaveCheckBox->isChecked() ? m_autosaveSpinBox->value() * 60 : 0;
 }
 
 int GeneralTab::undoStackSize()
 {
     return m_undoStackSize->value();
 }
 
 bool GeneralTab::showOutlineWhilePainting()
 {
     return m_showOutlinePainting->isChecked();
 }
 
 int GeneralTab::mdiMode()
 {
     return m_cmbMDIType->currentIndex();
 }
 
 int GeneralTab::favoritePresets()
 {
     return m_favoritePresetsSpinBox->value();
 }
 
 bool GeneralTab::showCanvasMessages()
 {
     return m_chkCanvasMessages->isChecked();
 }
 
 bool GeneralTab::compressKra()
 {
     return m_chkCompressKra->isChecked();
 }
 
 bool GeneralTab::useZip64()
 {
     return chkZip64->isChecked();
 }
 
 bool GeneralTab::toolOptionsInDocker()
 {
     return m_radioToolOptionsInDocker->isChecked();
 }
 
 bool GeneralTab::kineticScrollingEnabled()
 {
     return m_groupBoxKineticScrollingSettings->isChecked();
 }
 
 int GeneralTab::kineticScrollingGesture()
 {
     return m_cmbKineticScrollingGesture->currentIndex();
 }
 
 int GeneralTab::kineticScrollingSensitivity()
 {
     return m_kineticScrollingSensitivitySlider->value();
 }
 
 bool GeneralTab::kineticScrollingHiddenScrollbars()
 {
     return m_chkKineticScrollingHideScrollbars->isChecked();
 }
 
 bool GeneralTab::switchSelectionCtrlAlt()
 {
     return m_chkSwitchSelectionCtrlAlt->isChecked();
 
 }
 
 bool GeneralTab::convertToImageColorspaceOnImport()
 {
     return m_chkConvertOnImport->isChecked();
 }
 
 void GeneralTab::getBackgroundImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BackgroundImages");
     dialog.setCaption(i18n("Select a Background Image"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setImageFilters();
 
     QString fn = dialog.filename();
     // dialog box was canceled or somehow no file was selected
     if (fn.isEmpty()) {
         return;
     }
 
     QImage image(fn);
     if (image.isNull()) {
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("%1 is not a valid image file!", fn));
     }
     else {
         m_backgroundimage->setText(fn);
     }
 }
 
 void GeneralTab::clearBackgroundImage()
 {
     // clearing the background image text will implicitly make the background color be used
     m_backgroundimage->setText("");
 }
 
 #include "kactioncollection.h"
 #include "KisActionsSnapshot.h"
 
 ShortcutSettingsTab::ShortcutSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgShortcutSettings(this);
     l->addWidget(m_page, 0, 0);
 
 
     m_snapshot.reset(new KisActionsSnapshot);
 
     KActionCollection *collection =
         KisPart::instance()->currentMainwindow()->actionCollection();
 
     Q_FOREACH (QAction *action, collection->actions()) {
         m_snapshot->addAction(action->objectName(), action);
     }
 
     QMap<QString, KActionCollection*> sortedCollections =
         m_snapshot->actionCollections();
 
     for (auto it = sortedCollections.constBegin(); it != sortedCollections.constEnd(); ++it) {
         m_page->addCollection(it.value(), it.key());
     }
 }
 
 ShortcutSettingsTab::~ShortcutSettingsTab()
 {
 }
 
 void ShortcutSettingsTab::setDefault()
 {
     m_page->allDefault();
 }
 
 void ShortcutSettingsTab::saveChanges()
 {
     m_page->save();
     KisActionRegistry::instance()->settingsPageSaved();
 }
 
 void ShortcutSettingsTab::cancelChanges()
 {
     m_page->undo();
 }
 
 ColorSettingsTab::ColorSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     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->setMargin(0);
     m_page = new WdgColorSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg(true);
 
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile());
     connect(m_page->chkUseSystemMonitorProfile, SIGNAL(toggled(bool)), this, SLOT(toggleAllowMonitorProfileSelection(bool)));
 
     m_page->cmbWorkingColorSpace->setIDList(KoColorSpaceRegistry::instance()->listKeys());
     m_page->cmbWorkingColorSpace->setCurrent(cfg.workingColorSpace());
 
     m_page->bnAddColorProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     m_page->bnAddColorProfile->setToolTip( i18n("Open Color Profile") );
     connect(m_page->bnAddColorProfile, SIGNAL(clicked()), SLOT(installProfile()));
 
     QFormLayout *monitorProfileGrid = new QFormLayout(m_page->monitorprofileholder);
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         QLabel *lbl = new QLabel(i18nc("The number of the screen", "Screen %1:", i + 1));
         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::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation());
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization());
     m_page->chkForcePaletteColor->setChecked(cfg.forcePaletteColors());
     KisImageConfig cfgImage(true);
 
     KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
     m_page->sldAdaptationState->setMaximum(20);
     m_page->sldAdaptationState->setMinimum(0);
     m_page->sldAdaptationState->setValue((int)proofingConfig->adaptationState*20);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,
                                                                                       proofingConfig->proofingDepth,
                                                                                       proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
 
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
 
     m_pasteBehaviourGroup.addButton(m_page->radioPasteWeb, PASTE_ASSUME_WEB);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteMonitor, PASTE_ASSUME_MONITOR);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteAsk, PASTE_ASK);
 
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour());
     Q_ASSERT(button);
 
     if (button) {
         button->setChecked(true);
     }
 
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent());
 
     toggleAllowMonitorProfileSelection(cfg.useSystemMonitorProfile());
 
 }
 
 void ColorSettingsTab::installProfile()
 {
     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::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
 }
 
 void ColorSettingsTab::toggleAllowMonitorProfileSelection(bool useSystemProfile)
 {
     KisConfig cfg(true);
 
     if (useSystemProfile) {
         QStringList devices = KisColorManager::instance()->devices();
         if (devices.size() == QApplication::desktop()->screenCount()) {
             for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->clear();
                 QString monitorForScreen = cfg.monitorForScreen(i, devices[i]);
                 Q_FOREACH (const QString &device, devices) {
                     m_monitorProfileLabels[i]->setText(i18nc("The display/screen we got from Qt", "Screen %1:", i + 1));
                     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::desktop()->screenCount(); ++i) {
             if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                 m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
             }
         }
     }
 }
 
 void ColorSettingsTab::setDefault()
 {
     m_page->cmbWorkingColorSpace->setCurrent("RGBA");
 
     refillMonitorProfiles(KoID("RGBA"));
 
     KisConfig cfg(true);
     KisImageConfig cfgImage(true);
     KisProofingConfigurationSP proofingConfig =  cfgImage.defaultProofingconfiguration();
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,proofingConfig->proofingDepth,proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
     m_page->sldAdaptationState->setValue(0);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     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));
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile(true));
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour(true));
     Q_ASSERT(button);
     if (button) {
         button->setChecked(true);
     }
 }
 
 
 void ColorSettingsTab::refillMonitorProfiles(const KoID & colorSpaceId)
 {
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++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::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
             }
         }
     }
 
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         m_monitorProfileLabels[i]->setText(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileWidgets[i]->setCurrent(KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId.id()));
     }
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 void TabletSettingsTab::setDefault()
 {
     KisCubicCurve curve;
     curve.fromString(DEFAULT_CURVE_STRING);
     m_page->pressureCurve->setCurve(curve);
 
     m_page->chkUseRightMiddleClickWorkaround->setChecked(
         KisConfig(true).useRightMiddleTabletButtonWorkaround(true));
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 
 #ifdef USE_QT_TABLET_WINDOWS
     // ask Qt if WinInk is actually available
     const bool isWinInkAvailable = true;
 #else
     const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
     if (isWinInkAvailable) {
         KisConfig cfg(true);
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput(true));
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput(true));
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
     }
 #else
         m_page->grpTabletApi->setVisible(false);
 #endif
 }
 
 TabletSettingsTab::TabletSettingsTab(QWidget* parent, const char* name): QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgTabletSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg(true);
     KisCubicCurve curve;
     curve.fromString( cfg.pressureTabletCurve() );
 
     m_page->pressureCurve->setMaximumSize(QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
     m_page->pressureCurve->setCurve(curve);
 
     m_page->chkUseRightMiddleClickWorkaround->setChecked(
          cfg.useRightMiddleTabletButtonWorkaround());
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 #ifdef USE_QT_TABLET_WINDOWS
     // ask Qt if WinInk is actually available
     const bool isWinInkAvailable = true;
 #else
     const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
     if (isWinInkAvailable) {
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput());
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput());
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
         m_page->grpTabletApi->setVisible(false);
     }
 
 #ifdef USE_QT_TABLET_WINDOWS
     connect(m_page->btnResolutionSettings, SIGNAL(clicked()), SLOT(slotResolutionSettings()));
     connect(m_page->radioWintab, SIGNAL(toggled(bool)), m_page->btnResolutionSettings, SLOT(setEnabled(bool)));
     m_page->btnResolutionSettings->setEnabled(m_page->radioWintab->isChecked());
 #else
     m_page->btnResolutionSettings->setVisible(false);
 #endif
 
 #else
     m_page->grpTabletApi->setVisible(false);
 #endif
     connect(m_page->btnTabletTest, SIGNAL(clicked()), SLOT(slotTabletTest()));
 }
 
 void TabletSettingsTab::slotTabletTest()
 {
     TabletTestDialog tabletTestDialog(this);
     tabletTestDialog.exec();
 }
 
 #if defined Q_OS_WIN && defined USE_QT_TABLET_WINDOWS
 #include "KisDlgCustomTabletResolution.h"
 #endif
 
 void TabletSettingsTab::slotResolutionSettings()
 {
 #if defined Q_OS_WIN && defined USE_QT_TABLET_WINDOWS
     KisDlgCustomTabletResolution dlg(this);
     dlg.exec();
 #endif
 }
 
 
 //---------------------------------------------------------------------------------------------------
 #include "kis_acyclic_signal_connector.h"
 
 int getTotalRAM()
 {
     return KisImageConfig(true).totalRAM();
 }
 
 int PerformanceTab::realTilesRAM()
 {
     return intMemoryLimit->value() - intPoolLimit->value();
 }
 
 PerformanceTab::PerformanceTab(QWidget *parent, const char *name)
     : WdgPerformanceSettings(parent, name)
 {
     KisImageConfig cfg(true);
     const double totalRAM = cfg.totalRAM();
     lblTotalMemory->setText(KFormat().formatByteSize(totalRAM * 1024 * 1024, 0, KFormat::IECBinaryDialect, KFormat::UnitMegaByte));
 
     sliderMemoryLimit->setSuffix(i18n(" %"));
     sliderMemoryLimit->setRange(1, 100, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderPoolLimit->setSuffix(i18n(" %"));
     sliderPoolLimit->setRange(0, 20, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderUndoLimit->setSuffix(i18n(" %"));
     sliderUndoLimit->setRange(0, 50, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     intMemoryLimit->setMinimumWidth(80);
     intPoolLimit->setMinimumWidth(80);
     intUndoLimit->setMinimumWidth(80);
 
 
     SliderAndSpinBoxSync *sync1 =
         new SliderAndSpinBoxSync(sliderMemoryLimit,
                                  intMemoryLimit,
                                  getTotalRAM);
 
     sync1->slotParentValueChanged();
     m_syncs << sync1;
 
     SliderAndSpinBoxSync *sync2 =
         new SliderAndSpinBoxSync(sliderPoolLimit,
                                  intPoolLimit,
                                  std::bind(&KisIntParseSpinBox::value,
                                              intMemoryLimit));
 
 
     connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync2, SLOT(slotParentValueChanged()));
     sync2->slotParentValueChanged();
     m_syncs << sync2;
 
     SliderAndSpinBoxSync *sync3 =
         new SliderAndSpinBoxSync(sliderUndoLimit,
                                  intUndoLimit,
                                  std::bind(&PerformanceTab::realTilesRAM,
                                              this));
 
 
     connect(intPoolLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
     sync3->slotParentValueChanged();
     m_syncs << sync3;
 
     sliderSwapSize->setSuffix(i18n(" GiB"));
     sliderSwapSize->setRange(1, 64);
     intSwapSize->setRange(1, 64);
 
 
     KisAcyclicSignalConnector *swapSizeConnector = new KisAcyclicSignalConnector(this);
 
     swapSizeConnector->connectForwardInt(sliderSwapSize, SIGNAL(valueChanged(int)),
                                          intSwapSize, SLOT(setValue(int)));
 
     swapSizeConnector->connectBackwardInt(intSwapSize, SIGNAL(valueChanged(int)),
                                           sliderSwapSize, SLOT(setValue(int)));
 
     lblSwapFileLocation->setText(cfg.swapDir());
     connect(bnSwapFile, SIGNAL(clicked()), SLOT(selectSwapDir()));
 
     sliderThreadsLimit->setRange(1, QThread::idealThreadCount());
     sliderFrameClonesLimit->setRange(1, QThread::idealThreadCount());
     sliderFpsLimit->setRange(20, 100);
     sliderFpsLimit->setSuffix(i18n(" fps"));
 
     connect(sliderThreadsLimit, SIGNAL(valueChanged(int)), SLOT(slotThreadsLimitChanged(int)));
     connect(sliderFrameClonesLimit, SIGNAL(valueChanged(int)), SLOT(slotFrameClonesLimitChanged(int)));
 
     intCachedFramesSizeLimit->setRange(1, 10000);
     intCachedFramesSizeLimit->setSuffix(i18n(" px"));
     intCachedFramesSizeLimit->setSingleStep(1);
     intCachedFramesSizeLimit->setPageStep(1000);
 
     intRegionOfInterestMargin->setRange(1, 100);
     intRegionOfInterestMargin->setSuffix(i18n(" %"));
     intRegionOfInterestMargin->setSingleStep(1);
     intRegionOfInterestMargin->setPageStep(10);
 
     connect(chkCachedFramesSizeLimit, SIGNAL(toggled(bool)), intCachedFramesSizeLimit, SLOT(setEnabled(bool)));
     connect(chkUseRegionOfInterest, SIGNAL(toggled(bool)), intRegionOfInterestMargin, SLOT(setEnabled(bool)));
 
 #ifndef Q_OS_WIN
     // AVX workaround is needed on Windows+GCC only
     chkDisableAVXOptimizations->setVisible(false);
 #endif
 
     load(false);
 }
 
 PerformanceTab::~PerformanceTab()
 {
     qDeleteAll(m_syncs);
 }
 
 void PerformanceTab::load(bool requestDefault)
 {
     KisImageConfig cfg(true);
 
     sliderMemoryLimit->setValue(cfg.memoryHardLimitPercent(requestDefault));
     sliderPoolLimit->setValue(cfg.memoryPoolLimitPercent(requestDefault));
     sliderUndoLimit->setValue(cfg.memorySoftLimitPercent(requestDefault));
 
     chkPerformanceLogging->setChecked(cfg.enablePerfLog(requestDefault));
     chkProgressReporting->setChecked(cfg.enableProgressReporting(requestDefault));
 
     sliderSwapSize->setValue(cfg.maxSwapSize(requestDefault) / 1024);
     lblSwapFileLocation->setText(cfg.swapDir(requestDefault));
 
     m_lastUsedThreadsLimit = cfg.maxNumberOfThreads(requestDefault);
     m_lastUsedClonesLimit = cfg.frameRenderingClones(requestDefault);
 
     sliderThreadsLimit->setValue(m_lastUsedThreadsLimit);
     sliderFrameClonesLimit->setValue(m_lastUsedClonesLimit);
 
     sliderFpsLimit->setValue(cfg.fpsLimit(requestDefault));
 
     {
         KisConfig cfg2(true);
         chkOpenGLFramerateLogging->setChecked(cfg2.enableOpenGLFramerateLogging(requestDefault));
         chkBrushSpeedLogging->setChecked(cfg2.enableBrushSpeedLogging(requestDefault));
         chkDisableVectorOptimizations->setChecked(cfg2.enableAmdVectorizationWorkaround(requestDefault));
 #ifdef Q_OS_WIN
         chkDisableAVXOptimizations->setChecked(cfg2.disableAVXOptimizations(requestDefault));
 #endif
         chkBackgroundCacheGeneration->setChecked(cfg2.calculateAnimationCacheInBackground(requestDefault));
     }
 
     if (cfg.useOnDiskAnimationCacheSwapping(requestDefault)) {
         optOnDisk->setChecked(true);
     } else {
         optInMemory->setChecked(true);
     }
 
     chkCachedFramesSizeLimit->setChecked(cfg.useAnimationCacheFrameSizeLimit(requestDefault));
     intCachedFramesSizeLimit->setValue(cfg.animationCacheFrameSizeLimit(requestDefault));
     intCachedFramesSizeLimit->setEnabled(chkCachedFramesSizeLimit->isChecked());
 
     chkUseRegionOfInterest->setChecked(cfg.useAnimationCacheRegionOfInterest(requestDefault));
     intRegionOfInterestMargin->setValue(cfg.animationCacheRegionOfInterestMargin(requestDefault) * 100.0);
     intRegionOfInterestMargin->setEnabled(chkUseRegionOfInterest->isChecked());
 }
 
 void PerformanceTab::save()
 {
     KisImageConfig cfg(false);
 
     cfg.setMemoryHardLimitPercent(sliderMemoryLimit->value());
     cfg.setMemorySoftLimitPercent(sliderUndoLimit->value());
     cfg.setMemoryPoolLimitPercent(sliderPoolLimit->value());
 
     cfg.setEnablePerfLog(chkPerformanceLogging->isChecked());
     cfg.setEnableProgressReporting(chkProgressReporting->isChecked());
 
     cfg.setMaxSwapSize(sliderSwapSize->value() * 1024);
 
     cfg.setSwapDir(lblSwapFileLocation->text());
 
     cfg.setMaxNumberOfThreads(sliderThreadsLimit->value());
     cfg.setFrameRenderingClones(sliderFrameClonesLimit->value());
     cfg.setFpsLimit(sliderFpsLimit->value());
 
     {
         KisConfig cfg2(true);
         cfg2.setEnableOpenGLFramerateLogging(chkOpenGLFramerateLogging->isChecked());
         cfg2.setEnableBrushSpeedLogging(chkBrushSpeedLogging->isChecked());
         cfg2.setEnableAmdVectorizationWorkaround(chkDisableVectorOptimizations->isChecked());
 #ifdef Q_OS_WIN
         cfg2.setDisableAVXOptimizations(chkDisableAVXOptimizations->isChecked());
 #endif
         cfg2.setCalculateAnimationCacheInBackground(chkBackgroundCacheGeneration->isChecked());
     }
 
     cfg.setUseOnDiskAnimationCacheSwapping(optOnDisk->isChecked());
 
     cfg.setUseAnimationCacheFrameSizeLimit(chkCachedFramesSizeLimit->isChecked());
     cfg.setAnimationCacheFrameSizeLimit(intCachedFramesSizeLimit->value());
 
     cfg.setUseAnimationCacheRegionOfInterest(chkUseRegionOfInterest->isChecked());
     cfg.setAnimationCacheRegionOfInterestMargin(intRegionOfInterestMargin->value() / 100.0);
 
 }
 
 void PerformanceTab::selectSwapDir()
 {
     KisImageConfig cfg(true);
     QString swapDir = cfg.swapDir();
     swapDir = QFileDialog::getExistingDirectory(0, i18nc("@title:window", "Select a swap directory"), swapDir);
     if (swapDir.isEmpty()) {
         return;
     }
     lblSwapFileLocation->setText(swapDir);
 }
 
 void PerformanceTab::slotThreadsLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderFrameClonesLimit);
     sliderFrameClonesLimit->setValue(qMin(m_lastUsedClonesLimit, value));
     m_lastUsedThreadsLimit = value;
 }
 
 void PerformanceTab::slotFrameClonesLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderThreadsLimit);
     sliderThreadsLimit->setValue(qMax(m_lastUsedThreadsLimit, value));
     m_lastUsedClonesLimit = value;
 }
 
 //---------------------------------------------------------------------------------------------------
 
 #include "KoColor.h"
 #include "opengl/KisOpenGLModeProber.h"
 #include "opengl/KisScreenInformationAdapter.h"
 #include <QOpenGLContext>
 #include <QScreen>
 
 QString colorSpaceString(KisSurfaceColorSpace cs, int depth)
 {
     const QString csString =
 #ifdef HAVE_HDR
         cs == KisSurfaceColorSpace::bt2020PQColorSpace ? "Rec. 2020 PQ" :
         cs == KisSurfaceColorSpace::scRGBColorSpace ? "Rec. 709 Linear" :
 #endif
         cs == KisSurfaceColorSpace::sRGBColorSpace ? "sRGB" :
         cs == KisSurfaceColorSpace::DefaultColorSpace ? "sRGB" :
         "Unknown Color Space";
 
     return QString("%1 (%2 bit)").arg(csString).arg(depth);
 }
 
 int formatToIndex(KisConfig::RootSurfaceFormat fmt)
 {
     return fmt == KisConfig::BT2020_PQ ? 1 :
            fmt == KisConfig::BT709_G10 ? 2 :
            0;
 }
 
 KisConfig::RootSurfaceFormat indexToFormat(int value)
 {
     return value == 1 ? KisConfig::BT2020_PQ :
            value == 2 ? KisConfig::BT709_G10 :
            KisConfig::BT709_G22;
 }
 
 DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
     : 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 = i18nc("canvas renderer", "Direct3D 11 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);
         }
     }
 
 #ifdef Q_OS_WIN
     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);
         }
     }
 #endif
 
     if (!(supportedRenderers &
           (KisOpenGL::RendererDesktopGL |
            KisOpenGL::RendererOpenGLES |
            KisOpenGL::RendererSoftware))) {
 
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     } else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL());
         chkUseTextureBuffer->setEnabled(cfg.useOpenGL());
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer());
         chkDisableVsync->setVisible(cfg.showAdvancedOpenGLSettings());
         chkDisableVsync->setEnabled(cfg.useOpenGL());
         chkDisableVsync->setChecked(cfg.disableVSync());
         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);
         }
     }
 
     lblCurrentDisplayFormat->setText("");
     lblCurrentRootSurfaceFormat->setText("");
     lblHDRWarning->setText("");
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::sRGBColorSpace, 8));
 #ifdef HAVE_HDR
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::bt2020PQColorSpace, 10));
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::scRGBColorSpace, 16));
 #endif
     cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
     slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
 
     QOpenGLContext *context = QOpenGLContext::currentContext();
 
     if (!context) {
         context = QOpenGLContext::globalShareContext();
     }
 
     if (context) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         QScreen *screen = QGuiApplication::screenAt(rect().center());
 #else
         QScreen *screen = 0;
 #endif
         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();
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         KisSurfaceColorSpace colorSpace = currentFormat.colorSpace();
 #else
         KisSurfaceColorSpace colorSpace = KisSurfaceColorSpace::DefaultColorSpace;
 #endif
         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
     grpHDRSettings->setVisible(false);
 #endif
 
     const QStringList openglWarnings = KisOpenGL::getOpenGLWarnings();
     if (openglWarnings.isEmpty()) {
         lblOpenGLWarnings->setVisible(false);
     } else {
         QString text("<span style=\"color: yellow;\">&#x26A0;</span> ");
         text.append(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>");
         lblOpenGLWarnings->setText(text);
         lblOpenGLWarnings->setVisible(true);
     }
 
     if (qApp->applicationName() == "kritasketch" || qApp->applicationName() == "kritagemini") {
        grpOpenGL->setVisible(false);
        grpOpenGL->setMaximumHeight(0);
     }
 
     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());
 
     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);
 }
 
 void DisplaySettingsTab::setDefault()
 {
     KisConfig cfg(true);
     cmbPreferredRenderer->setCurrentIndex(0);
     if (!(KisOpenGL::getSupportedOpenGLRenderers() &
             (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererOpenGLES))) {
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     }
     else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL(true));
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer(true));
         chkUseTextureBuffer->setEnabled(true);
         chkDisableVsync->setEnabled(true);
         chkDisableVsync->setChecked(cfg.disableVSync(true));
         cmbFilterMode->setEnabled(true);
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode(true));
     }
 
     chkMoving->setChecked(cfg.scrollCheckers(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);
 
     cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
     slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
 }
 
 void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
 {
     chkUseTextureBuffer->setEnabled(isChecked);
     chkDisableVsync->setEnabled(isChecked);
     cmbFilterMode->setEnabled(isChecked);
 }
 
 void DisplaySettingsTab::slotPreferredSurfaceFormatChanged(int index)
 {
     Q_UNUSED(index);
 
     QOpenGLContext *context = QOpenGLContext::currentContext();
     if (context) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         QScreen *screen = QGuiApplication::screenAt(rect().center());
 #else
         QScreen *screen = 0;
 #endif
         KisScreenInformationAdapter adapter(context);
         if (adapter.isValid()) {
             KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
             if (info.isValid()) {
                 if (cmbPreferedRootSurfaceFormat->currentIndex() != formatToIndex(KisConfig::BT709_G22) &&
                     info.colorSpace == KisSurfaceColorSpace::sRGBColorSpace) {
                     lblHDRWarning->setText(i18n("WARNING: current display doesn't support HDR rendering"));
                 } else {
                     lblHDRWarning->setText("");
                 }
             }
         }
     }
 }
 
 //---------------------------------------------------------------------------------------------------
 FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
 {
     KisConfig cfg(true);
 
     chkDockers->setChecked(cfg.hideDockersFullscreen());
     chkMenu->setChecked(cfg.hideMenuFullscreen());
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen());
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen());
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen());
     chkToolbar->setChecked(cfg.hideToolbarFullscreen());
 
 }
 
 void FullscreenSettingsTab::setDefault()
 {
     KisConfig cfg(true);
     chkDockers->setChecked(cfg.hideDockersFullscreen(true));
     chkMenu->setChecked(cfg.hideMenuFullscreen(true));
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen(true));
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen(true));
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen(true));
     chkToolbar->setChecked(cfg.hideToolbarFullscreen(true));
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 KisDlgPreferences::KisDlgPreferences(QWidget* parent, const char* name)
     : KPageDialog(parent)
 {
     Q_UNUSED(name);
     setWindowTitle(i18n("Configure Krita"));
     setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::RestoreDefaults);
 
     setFaceType(KPageDialog::Tree);
 
     // General
     KoVBox *vbox = new KoVBox();
     KPageWidgetItem *page = new KPageWidgetItem(vbox, i18n("General"));
     page->setObjectName("general");
     page->setHeader(i18n("General"));
     page->setIcon(KisIconUtils::loadIcon("go-home"));
     m_pages << page;
     addPage(page);
     m_general = new GeneralTab(vbox);
 
     // Shortcuts
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Keyboard Shortcuts"));
     page->setObjectName("shortcuts");
     page->setHeader(i18n("Shortcuts"));
     page->setIcon(KisIconUtils::loadIcon("document-export"));
     m_pages << page;
     addPage(page);
     m_shortcutSettings = new ShortcutSettingsTab(vbox);
     connect(this, SIGNAL(accepted()), m_shortcutSettings, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_shortcutSettings, SLOT(cancelChanges()));
 
     // Canvas input settings
     m_inputConfiguration = new KisInputConfigurationPage();
     page = addPage(m_inputConfiguration, i18n("Canvas Input Settings"));
     page->setHeader(i18n("Canvas Input"));
     page->setObjectName("canvasinput");
     page->setIcon(KisIconUtils::loadIcon("configure"));
     m_pages << page;
 
     // Display
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Display"));
     page->setObjectName("display");
     page->setHeader(i18n("Display"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-display"));
     m_pages << page;
     addPage(page);
     m_displaySettings = new DisplaySettingsTab(vbox);
 
     // Color
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Color Management"));
     page->setObjectName("colormanagement");
     page->setHeader(i18n("Color"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-color"));
     m_pages << page;
     addPage(page);
     m_colorSettings = new ColorSettingsTab(vbox);
 
     // Performance
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Performance"));
     page->setObjectName("performance");
     page->setHeader(i18n("Performance"));
     page->setIcon(KisIconUtils::loadIcon("applications-system"));
     m_pages << page;
     addPage(page);
     m_performanceSettings = new PerformanceTab(vbox);
 
     // Tablet
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Tablet settings"));
     page->setObjectName("tablet");
     page->setHeader(i18n("Tablet"));
     page->setIcon(KisIconUtils::loadIcon("document-edit"));
     m_pages << page;
     addPage(page);
     m_tabletSettings = new TabletSettingsTab(vbox);
 
     // full-screen mode
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Canvas-only settings"));
     page->setObjectName("canvasonly");
     page->setHeader(i18n("Canvas-only"));
     page->setIcon(KisIconUtils::loadIcon("folder-pictures"));
     m_pages << page;
     addPage(page);
     m_fullscreenSettings = new FullscreenSettingsTab(vbox);
 
     // Author profiles
     m_authorPage = new KoConfigAuthorPage();
     page = addPage(m_authorPage, i18nc("@title:tab Author page", "Author" ));
     page->setObjectName("author");
     page->setHeader(i18n("Author"));
     page->setIcon(KisIconUtils::loadIcon("im-user"));
     m_pages << page;
 
 
     QPushButton *restoreDefaultsButton = button(QDialogButtonBox::RestoreDefaults);
     restoreDefaultsButton->setText(i18nc("@action:button", "Restore Defaults"));
 
     connect(this, SIGNAL(accepted()), m_inputConfiguration, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_inputConfiguration, SLOT(revertChanges()));
 
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     Q_FOREACH (KisAbstractPreferenceSetFactory *preferenceSetFactory, preferenceSetRegistry->values()) {
         KisPreferenceSet* preferenceSet = preferenceSetFactory->createPreferenceSet();
         vbox = new KoVBox();
         page = new KPageWidgetItem(vbox, preferenceSet->name());
         page->setHeader(preferenceSet->header());
         page->setIcon(preferenceSet->icon());
         addPage(page);
         preferenceSet->setParent(vbox);
         preferenceSet->loadPreferences();
 
         connect(restoreDefaultsButton, SIGNAL(clicked(bool)), preferenceSet, SLOT(loadDefaultPreferences()), Qt::UniqueConnection);
         connect(this, SIGNAL(accepted()), preferenceSet, SLOT(savePreferences()), Qt::UniqueConnection);
     }
 
     connect(restoreDefaultsButton, SIGNAL(clicked(bool)), this, SLOT(slotDefault()));
 
     KisConfig cfg(true);
     QString currentPageName = cfg.readEntry<QString>("KisDlgPreferences/CurrentPage");
     Q_FOREACH(KPageWidgetItem *page, m_pages) {
         if (page->objectName() == currentPageName) {
             setCurrentPage(page);
             break;
         }
     }
 }
 
 KisDlgPreferences::~KisDlgPreferences()
 {
     KisConfig cfg(true);
     cfg.writeEntry<QString>("KisDlgPreferences/CurrentPage", currentPage()->objectName());
 }
 
 void KisDlgPreferences::showEvent(QShowEvent *event){
     KPageDialog::showEvent(event);
     button(QDialogButtonBox::Cancel)->setAutoDefault(false);
     button(QDialogButtonBox::Ok)->setAutoDefault(false);
     button(QDialogButtonBox::RestoreDefaults)->setAutoDefault(false);
     button(QDialogButtonBox::Cancel)->setDefault(false);
     button(QDialogButtonBox::Ok)->setDefault(false);
     button(QDialogButtonBox::RestoreDefaults)->setDefault(false);
 }
 
 void KisDlgPreferences::slotDefault()
 {
     if (currentPage()->objectName() == "general") {
         m_general->setDefault();
     }
     else if (currentPage()->objectName() == "shortcuts") {
         m_shortcutSettings->setDefault();
     }
     else if (currentPage()->objectName() == "display") {
         m_displaySettings->setDefault();
     }
     else if (currentPage()->objectName() == "colormanagement") {
         m_colorSettings->setDefault();
     }
     else if (currentPage()->objectName() == "performance") {
         m_performanceSettings->load(true);
     }
     else if (currentPage()->objectName() == "tablet") {
         m_tabletSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasonly") {
         m_fullscreenSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasinput") {
         m_inputConfiguration->setDefaults();
     }
 }
 
 bool KisDlgPreferences::editPreferences()
 {
     KisDlgPreferences* dialog;
 
     dialog = new KisDlgPreferences();
     bool baccept = (dialog->exec() == Accepted);
     if (baccept) {
         // General settings
         KisConfig cfg(false);
         cfg.setNewCursorStyle(dialog->m_general->cursorStyle());
         cfg.setNewOutlineStyle(dialog->m_general->outlineStyle());
         cfg.setShowRootLayer(dialog->m_general->showRootLayer());
         cfg.setShowOutlineWhilePainting(dialog->m_general->showOutlineWhilePainting());
         cfg.setForceAlwaysFullSizedOutline(!dialog->m_general->m_changeBrushOutline->isChecked());
         cfg.setSessionOnStartup(dialog->m_general->sessionOnStartup());
         cfg.setSaveSessionOnQuit(dialog->m_general->saveSessionOnQuit());
 
         KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
         group.writeEntry("DontUseNativeFileDialog", !dialog->m_general->m_chkNativeFileDialog->isChecked());
 
         cfg.writeEntry<int>("maximumBrushSize", dialog->m_general->intMaxBrushSize->value());
 
         cfg.writeEntry<int>("mdi_viewmode", dialog->m_general->mdiMode());
         cfg.setMDIBackgroundColor(dialog->m_general->m_mdiColor->color().toXML());
         cfg.setMDIBackgroundImage(dialog->m_general->m_backgroundimage->text());
         cfg.setAutoSaveInterval(dialog->m_general->autoSaveInterval());
         cfg.writeEntry("autosavefileshidden", dialog->m_general->chkHideAutosaveFiles->isChecked());
 
         cfg.setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
         cfg.writeEntry("backupfilelocation", dialog->m_general->cmbBackupFileLocation->currentIndex());
         cfg.writeEntry("backupfilesuffix", dialog->m_general->txtBackupFileSuffix->text());
         cfg.writeEntry("numberofbackupfiles", dialog->m_general->intNumBackupFiles->value());
 
         cfg.setShowCanvasMessages(dialog->m_general->showCanvasMessages());
         cfg.setCompressKra(dialog->m_general->compressKra());
         cfg.setUseZip64(dialog->m_general->useZip64());
 
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("EnableHiDPI", dialog->m_general->m_chkHiDPI->isChecked());
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
         kritarc.setValue("EnableHiDPIFractionalScaling", dialog->m_general->m_chkHiDPIFractionalScaling->isChecked());
 #endif
         kritarc.setValue("EnableSingleApplication", dialog->m_general->m_chkSingleApplication->isChecked());
         kritarc.setValue("LogUsage", dialog->m_general->chkUsageLogging->isChecked());
 
         cfg.setToolOptionsInDocker(dialog->m_general->toolOptionsInDocker());
 
         cfg.writeEntry<bool>("useCreamyAlphaDarken", (bool)!dialog->m_general->cmbFlowMode->currentIndex());
 
         cfg.setKineticScrollingEnabled(dialog->m_general->kineticScrollingEnabled());
         cfg.setKineticScrollingGesture(dialog->m_general->kineticScrollingGesture());
         cfg.setKineticScrollingSensitivity(dialog->m_general->kineticScrollingSensitivity());
         cfg.setKineticScrollingHideScrollbars(dialog->m_general->kineticScrollingHiddenScrollbars());
 
         cfg.setSwitchSelectionCtrlAlt(dialog->m_general->switchSelectionCtrlAlt());
         cfg.setDisableTouchOnCanvas(!dialog->m_general->chkEnableTouch->isChecked());
         cfg.setActivateTransformToolAfterPaste(dialog->m_general->chkEnableTranformToolAfterPaste->isChecked());
         cfg.setConvertToImageColorspaceOnImport(dialog->m_general->convertToImageColorspaceOnImport());
         cfg.setUndoStackLimit(dialog->m_general->undoStackSize());
         cfg.setFavoritePresets(dialog->m_general->favoritePresets());
 
         // Color settings
         cfg.setUseSystemMonitorProfile(dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
         for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
                 int currentIndex = dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
                 QString monitorid = dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
                 cfg.setMonitorForScreen(i, monitorid);
             }
             else {
                 cfg.setMonitorProfile(i,
                                       dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentUnsqueezedText(),
                                       dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
         cfg.setWorkingColorSpace(dialog->m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
 
         KisImageConfig cfgImage(false);
         cfgImage.setDefaultProofingConfig(dialog->m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(),
                                           dialog->m_colorSettings->m_page->cmbProofingIntent->currentIndex(),
                                           dialog->m_colorSettings->m_page->ckbProofBlackPoint->isChecked(),
                                           dialog->m_colorSettings->m_page->gamutAlarm->color(),
                                           (double)dialog->m_colorSettings->m_page->sldAdaptationState->value()/20);
         cfg.setUseBlackPointCompensation(dialog->m_colorSettings->m_page->chkBlackpoint->isChecked());
         cfg.setAllowLCMSOptimization(dialog->m_colorSettings->m_page->chkAllowLCMSOptimization->isChecked());
         cfg.setForcePaletteColors(dialog->m_colorSettings->m_page->chkForcePaletteColor->isChecked());
         cfg.setPasteBehaviour(dialog->m_colorSettings->m_pasteBehaviourGroup.checkedId());
         cfg.setRenderIntent(dialog->m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
 
         // Tablet settings
         cfg.setPressureTabletCurve( dialog->m_tabletSettings->m_page->pressureCurve->curve().toString() );
         cfg.setUseRightMiddleTabletButtonWorkaround(
             dialog->m_tabletSettings->m_page->chkUseRightMiddleClickWorkaround->isChecked());
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 #ifdef USE_QT_TABLET_WINDOWS
         // ask Qt if WinInk is actually available
         const bool isWinInkAvailable = true;
 #else
         const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
         if (isWinInkAvailable) {
             cfg.setUseWin8PointerInput(dialog->m_tabletSettings->m_page->radioWin8PointerInput->isChecked());
         }
 #endif
 
         dialog->m_performanceSettings->save();
 
-        {
+        if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
+            cfg.setCanvasState("TRY_OPENGL");
+
+        if (dialog->m_displaySettings->grpOpenGL->isChecked()) {
             KisOpenGL::OpenGLRenderer renderer = static_cast<KisOpenGL::OpenGLRenderer>(
                     dialog->m_displaySettings->cmbPreferredRenderer->itemData(
                             dialog->m_displaySettings->cmbPreferredRenderer->currentIndex()).toInt());
             KisOpenGL::setUserPreferredOpenGLRendererConfig(renderer);
+        } else {
+            KisOpenGL::setUserPreferredOpenGLRendererConfig(KisOpenGL::RendererNone);
         }
 
-        if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
-            cfg.setCanvasState("TRY_OPENGL");
-        cfg.setUseOpenGL(dialog->m_displaySettings->grpOpenGL->isChecked());
         cfg.setUseOpenGLTextureBuffer(dialog->m_displaySettings->chkUseTextureBuffer->isChecked());
         cfg.setOpenGLFilteringMode(dialog->m_displaySettings->cmbFilterMode->currentIndex());
         cfg.setDisableVSync(dialog->m_displaySettings->chkDisableVsync->isChecked());
         cfg.setRootSurfaceFormat(&kritarc, indexToFormat(dialog->m_displaySettings->cmbPreferedRootSurfaceFormat->currentIndex()));
 
         cfg.setCheckSize(dialog->m_displaySettings->intCheckSize->value());
         cfg.setScrollingCheckers(dialog->m_displaySettings->chkMoving->isChecked());
         cfg.setCheckersColor1(dialog->m_displaySettings->colorChecks1->color().toQColor());
         cfg.setCheckersColor2(dialog->m_displaySettings->colorChecks2->color().toQColor());
         cfg.setCanvasBorderColor(dialog->m_displaySettings->canvasBorder->color().toQColor());
         cfg.setHideScrollbars(dialog->m_displaySettings->hideScrollbars->isChecked());
         KoColor c = dialog->m_displaySettings->btnSelectionOverlayColor->color();
         c.setOpacity(dialog->m_displaySettings->sldSelectionOverlayOpacity->value());
         cfgImage.setSelectionOverlayMaskColor(c.toQColor());
         cfg.setAntialiasCurves(dialog->m_displaySettings->chkCurveAntialiasing->isChecked());
         cfg.setAntialiasSelectionOutline(dialog->m_displaySettings->chkSelectionOutlineAntialiasing->isChecked());
         cfg.setShowSingleChannelAsColor(dialog->m_displaySettings->chkChannelsAsColor->isChecked());
         cfg.setHidePopups(dialog->m_displaySettings->chkHidePopups->isChecked());
 
         cfg.setHideDockersFullscreen(dialog->m_fullscreenSettings->chkDockers->checkState());
         cfg.setHideMenuFullscreen(dialog->m_fullscreenSettings->chkMenu->checkState());
         cfg.setHideScrollbarsFullscreen(dialog->m_fullscreenSettings->chkScrollbars->checkState());
         cfg.setHideStatusbarFullscreen(dialog->m_fullscreenSettings->chkStatusbar->checkState());
         cfg.setHideTitlebarFullscreen(dialog->m_fullscreenSettings->chkTitlebar->checkState());
         cfg.setHideToolbarFullscreen(dialog->m_fullscreenSettings->chkToolbar->checkState());
 
         cfg.setCursorMainColor(dialog->m_general->cursorColorBtutton->color().toQColor());
         cfg.setPixelGridColor(dialog->m_displaySettings->pixelGridColorButton->color().toQColor());
         cfg.setPixelGridDrawingThreshold(dialog->m_displaySettings->pixelGridDrawingThresholdBox->value() / 100);
 
         dialog->m_authorPage->apply();
 
     }
     delete dialog;
     return baccept;
 }
 
diff --git a/libs/ui/kis_config.cc b/libs/ui/kis_config.cc
index b81b35d856..e6d48e6f38 100644
--- a/libs/ui/kis_config.cc
+++ b/libs/ui/kis_config.cc
@@ -1,2151 +1,2147 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_config.h"
 
 #include <limits.h>
 
 #include <QtGlobal>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 #include <QFont>
 #include <QThread>
 #include <QStringList>
 #include <QSettings>
 #include <QStandardPaths>
 
 #include <kconfig.h>
 
 #include <KisDocument.h>
 
 #include <KoColor.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 
 #include <kis_debug.h>
 #include <kis_types.h>
 
 #include "kis_canvas_resource_provider.h"
 #include "kis_config_notifier.h"
 #include "kis_snap_config.h"
 
 #include <config-ocio.h>
 
 #include <kis_color_manager.h>
 #include <KisOcioConfiguration.h>
 
 #ifdef Q_OS_WIN
 #include "config_use_qt_tablet_windows.h"
 #endif
 
 KisConfig::KisConfig(bool readOnly)
     : m_cfg( KSharedConfig::openConfig()->group(""))
     , m_readOnly(readOnly)
 {
     if (!readOnly) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(qApp && qApp->thread() == QThread::currentThread());
     }
 }
 
 KisConfig::~KisConfig()
 {
     if (m_readOnly) return;
 
     if (qApp && qApp->thread() != QThread::currentThread()) {
         dbgKrita << "WARNING: KisConfig: requested config synchronization from nonGUI thread! Called from:" << kisBacktrace();
         return;
     }
 
     m_cfg.sync();
 }
 
 
 bool KisConfig::disableTouchOnCanvas(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("disableTouchOnCanvas", false));
 }
 
 void KisConfig::setDisableTouchOnCanvas(bool value) const
 {
     m_cfg.writeEntry("disableTouchOnCanvas", value);
 }
 
 bool KisConfig::useProjections(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useProjections", true));
 }
 
 void KisConfig::setUseProjections(bool useProj) const
 {
     m_cfg.writeEntry("useProjections", useProj);
 }
 
 bool KisConfig::undoEnabled(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("undoEnabled", true));
 }
 
 void KisConfig::setUndoEnabled(bool undo) const
 {
     m_cfg.writeEntry("undoEnabled", undo);
 }
 
 int KisConfig::undoStackLimit(bool defaultValue) const
 {
     return (defaultValue ? 30 : m_cfg.readEntry("undoStackLimit", 30));
 }
 
 void KisConfig::setUndoStackLimit(int limit) const
 {
     m_cfg.writeEntry("undoStackLimit", limit);
 }
 
 bool KisConfig::useCumulativeUndoRedo(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("useCumulativeUndoRedo",false));
 }
 
 void KisConfig::setCumulativeUndoRedo(bool value)
 {
     m_cfg.writeEntry("useCumulativeUndoRedo", value);
 }
 
 qreal KisConfig::stackT1(bool defaultValue) const
 {
      return (defaultValue ? 5 : m_cfg.readEntry("stackT1",5));
 }
 
 void KisConfig::setStackT1(int T1)
 {
     m_cfg.writeEntry("stackT1", T1);
 }
 
 qreal KisConfig::stackT2(bool defaultValue) const
 {
      return (defaultValue ? 1 : m_cfg.readEntry("stackT2",1));
 }
 
 void KisConfig::setStackT2(int T2)
 {
     m_cfg.writeEntry("stackT2", T2);
 }
 
 int KisConfig::stackN(bool defaultValue) const
 {
     return (defaultValue ? 5 : m_cfg.readEntry("stackN",5));
 }
 
 void KisConfig::setStackN(int N)
 {
      m_cfg.writeEntry("stackN", N);
 }
 
 qint32 KisConfig::defImageWidth(bool defaultValue) const
 {
     return (defaultValue ? 1600 : m_cfg.readEntry("imageWidthDef", 1600));
 }
 
 qint32 KisConfig::defImageHeight(bool defaultValue) const
 {
     return (defaultValue ? 1200 : m_cfg.readEntry("imageHeightDef", 1200));
 }
 
 qreal KisConfig::defImageResolution(bool defaultValue) const
 {
     return (defaultValue ? 100.0 : m_cfg.readEntry("imageResolutionDef", 100.0)) / 72.0;
 }
 
 QString KisConfig::defColorModel(bool defaultValue) const
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->colorModelId().id()
                         : m_cfg.readEntry("colorModelDef", KoColorSpaceRegistry::instance()->rgb8()->colorModelId().id()));
 }
 
 void KisConfig::defColorModel(const QString & model) const
 {
     m_cfg.writeEntry("colorModelDef", model);
 }
 
 QString KisConfig::defaultColorDepth(bool defaultValue) const
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->colorDepthId().id()
                         : m_cfg.readEntry("colorDepthDef", KoColorSpaceRegistry::instance()->rgb8()->colorDepthId().id()));
 }
 
 void KisConfig::setDefaultColorDepth(const QString & depth) const
 {
     m_cfg.writeEntry("colorDepthDef", depth);
 }
 
 QString KisConfig::defColorProfile(bool defaultValue) const
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->profile()->name() :
                            m_cfg.readEntry("colorProfileDef",
                                            KoColorSpaceRegistry::instance()->rgb8()->profile()->name()));
 }
 
 void KisConfig::defColorProfile(const QString & profile) const
 {
     m_cfg.writeEntry("colorProfileDef", profile);
 }
 
 void KisConfig::defImageWidth(qint32 width) const
 {
     m_cfg.writeEntry("imageWidthDef", width);
 }
 
 void KisConfig::defImageHeight(qint32 height) const
 {
     m_cfg.writeEntry("imageHeightDef", height);
 }
 
 void KisConfig::defImageResolution(qreal res) const
 {
     m_cfg.writeEntry("imageResolutionDef", res*72.0);
 }
 
 int KisConfig::preferredVectorImportResolutionPPI(bool defaultValue) const
 {
     return defaultValue ? 100.0 : m_cfg.readEntry("preferredVectorImportResolution", 100.0);
 }
 
 void KisConfig::setPreferredVectorImportResolutionPPI(int value) const
 {
     m_cfg.writeEntry("preferredVectorImportResolution", value);
 }
 
 void cleanOldCursorStyleKeys(KConfigGroup &cfg)
 {
     if (cfg.hasKey("newCursorStyle") &&
         cfg.hasKey("newOutlineStyle")) {
 
         cfg.deleteEntry("cursorStyleDef");
     }
 }
 
 CursorStyle KisConfig::newCursorStyle(bool defaultValue) const
 {
     if (defaultValue) {
         return CURSOR_STYLE_NO_CURSOR;
     }
 
 
     int style = m_cfg.readEntry("newCursorStyle", int(-1));
 
     if (style < 0) {
         // old style format
         style = m_cfg.readEntry("cursorStyleDef", int(OLD_CURSOR_STYLE_OUTLINE));
 
         switch (style) {
         case OLD_CURSOR_STYLE_TOOLICON:
             style = CURSOR_STYLE_TOOLICON;
             break;
         case OLD_CURSOR_STYLE_CROSSHAIR:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_CROSS:
             style = CURSOR_STYLE_CROSSHAIR;
             break;
         case OLD_CURSOR_STYLE_POINTER:
             style = CURSOR_STYLE_POINTER;
             break;
         case OLD_CURSOR_STYLE_OUTLINE:
         case OLD_CURSOR_STYLE_NO_CURSOR:
             style = CURSOR_STYLE_NO_CURSOR;
             break;
         case OLD_CURSOR_STYLE_SMALL_ROUND:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_DOT:
             style = CURSOR_STYLE_SMALL_ROUND;
             break;
         case OLD_CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_RIGHTHANDED:
             style = CURSOR_STYLE_TRIANGLE_RIGHTHANDED;
             break;
         case OLD_CURSOR_STYLE_TRIANGLE_LEFTHANDED:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_LEFTHANDED:
             style = CURSOR_STYLE_TRIANGLE_LEFTHANDED;
             break;
         default:
             style = -1;
         }
     }
 
     cleanOldCursorStyleKeys(m_cfg);
 
     // compatibility with future versions
     if (style < 0 || style >= N_CURSOR_STYLE_SIZE) {
         style = CURSOR_STYLE_NO_CURSOR;
     }
 
     return (CursorStyle) style;
 }
 
 void KisConfig::setNewCursorStyle(CursorStyle style)
 {
     m_cfg.writeEntry("newCursorStyle", (int)style);
 }
 
 QColor KisConfig::getCursorMainColor(bool defaultValue) const
 {
     QColor col;
     col.setRgbF(0.501961, 1.0, 0.501961);
     return (defaultValue ? col : m_cfg.readEntry("cursorMaincColor", col));
 }
 
 void KisConfig::setCursorMainColor(const QColor &v) const
 {
     m_cfg.writeEntry("cursorMaincColor", v);
 }
 
 OutlineStyle KisConfig::newOutlineStyle(bool defaultValue) const
 {
     if (defaultValue) {
         return OUTLINE_FULL;
     }
 
     int style = m_cfg.readEntry("newOutlineStyle", int(-1));
 
     if (style < 0) {
         // old style format
         style = m_cfg.readEntry("cursorStyleDef", int(OLD_CURSOR_STYLE_OUTLINE));
 
         switch (style) {
         case OLD_CURSOR_STYLE_TOOLICON:
         case OLD_CURSOR_STYLE_CROSSHAIR:
         case OLD_CURSOR_STYLE_POINTER:
         case OLD_CURSOR_STYLE_NO_CURSOR:
         case OLD_CURSOR_STYLE_SMALL_ROUND:
         case OLD_CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
         case OLD_CURSOR_STYLE_TRIANGLE_LEFTHANDED:
             style = OUTLINE_NONE;
             break;
         case OLD_CURSOR_STYLE_OUTLINE:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_DOT:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_CROSS:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_RIGHTHANDED:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_LEFTHANDED:
             style = OUTLINE_FULL;
             break;
         default:
             style = -1;
         }
     }
 
     cleanOldCursorStyleKeys(m_cfg);
 
     // compatibility with future versions
     if (style < 0 || style >= N_OUTLINE_STYLE_SIZE) {
         style = OUTLINE_FULL;
     }
 
     return (OutlineStyle) style;
 }
 
 void KisConfig::setNewOutlineStyle(OutlineStyle style)
 {
     m_cfg.writeEntry("newOutlineStyle", (int)style);
 }
 
 QRect KisConfig::colorPreviewRect() const
 {
     return m_cfg.readEntry("colorPreviewRect", QVariant(QRect(32, 32, 48, 48))).toRect();
 }
 
 void KisConfig::setColorPreviewRect(const QRect &rect)
 {
     m_cfg.writeEntry("colorPreviewRect", QVariant(rect));
 }
 
 bool KisConfig::useDirtyPresets(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useDirtyPresets",false));
 }
 void KisConfig::setUseDirtyPresets(bool value)
 {
     m_cfg.writeEntry("useDirtyPresets",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::useEraserBrushSize(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useEraserBrushSize",false));
 }
 
 void KisConfig::setUseEraserBrushSize(bool value)
 {
     m_cfg.writeEntry("useEraserBrushSize",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::useEraserBrushOpacity(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useEraserBrushOpacity",false));
 }
 
 void KisConfig::setUseEraserBrushOpacity(bool value)
 {
     m_cfg.writeEntry("useEraserBrushOpacity",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 
 QString KisConfig::getMDIBackgroundColor(bool defaultValue) const
 {
     QColor col(77, 77, 77);
     KoColor kol(KoColorSpaceRegistry::instance()->rgb8());
     kol.fromQColor(col);
     QString xml = kol.toXML();
     return (defaultValue ? xml : m_cfg.readEntry("mdiBackgroundColorXML", xml));
 }
 
 void KisConfig::setMDIBackgroundColor(const QString &v) const
 {
     m_cfg.writeEntry("mdiBackgroundColorXML", v);
 }
 
 QString KisConfig::getMDIBackgroundImage(bool defaultValue) const
 {
     return (defaultValue ? "" : m_cfg.readEntry("mdiBackgroundImage", ""));
 }
 
 void KisConfig::setMDIBackgroundImage(const QString &filename) const
 {
     m_cfg.writeEntry("mdiBackgroundImage", filename);
 }
 
 QString KisConfig::monitorProfile(int screen) const
 {
     // Note: keep this in sync with the default profile for the RGB colorspaces!
     QString profile = m_cfg.readEntry("monitorProfile" + QString(screen == 0 ? "": QString("_%1").arg(screen)), "sRGB-elle-V2-srgbtrc.icc");
     //dbgKrita << "KisConfig::monitorProfile()" << profile;
     return profile;
 }
 
 QString KisConfig::monitorForScreen(int screen, const QString &defaultMonitor, bool defaultValue) const
 {
     return (defaultValue ? defaultMonitor
                          : m_cfg.readEntry(QString("monitor_for_screen_%1").arg(screen), defaultMonitor));
 }
 
 void KisConfig::setMonitorForScreen(int screen, const QString& monitor)
 {
     m_cfg.writeEntry(QString("monitor_for_screen_%1").arg(screen), monitor);
 }
 
 void KisConfig::setMonitorProfile(int screen, const QString & monitorProfile, bool override) const
 {
     m_cfg.writeEntry("monitorProfile/OverrideX11", override);
     m_cfg.writeEntry("monitorProfile" + QString(screen == 0 ? "": QString("_%1").arg(screen)), monitorProfile);
 }
 
 const KoColorProfile *KisConfig::getScreenProfile(int screen)
 {
     if (screen < 0) return 0;
 
     KisConfig cfg(true);
     QString monitorId;
     if (KisColorManager::instance()->devices().size() > screen) {
         monitorId = cfg.monitorForScreen(screen, KisColorManager::instance()->devices()[screen]);
     }
     //dbgKrita << "getScreenProfile(). Screen" << screen << "monitor id" << monitorId;
 
     if (monitorId.isEmpty()) {
         return 0;
     }
 
     QByteArray bytes = KisColorManager::instance()->displayProfile(monitorId);
 
     //dbgKrita << "\tgetScreenProfile()" << bytes.size();
 
     if (bytes.length() > 0) {
         const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), bytes);
         //dbgKrita << "\tKisConfig::getScreenProfile for screen" << screen << profile->name();
         return profile;
     }
     else {
         //dbgKrita << "\tCould not get a system monitor profile";
         return 0;
     }
 }
 
 const KoColorProfile *KisConfig::displayProfile(int screen) const
 {
     if (screen < 0) return 0;
 
     // if the user plays with the settings, they can override the display profile, in which case
     // we don't want the system setting.
     bool override = useSystemMonitorProfile();
     //dbgKrita << "KisConfig::displayProfile(). Override X11:" << override;
     const KoColorProfile *profile = 0;
     if (override) {
         //dbgKrita << "\tGoing to get the screen profile";
         profile = KisConfig::getScreenProfile(screen);
     }
 
     // if it fails. check the configuration
     if (!profile || !profile->isSuitableForDisplay()) {
         //dbgKrita << "\tGoing to get the monitor profile";
         QString monitorProfileName = monitorProfile(screen);
         //dbgKrita << "\t\tmonitorProfileName:" << monitorProfileName;
         if (!monitorProfileName.isEmpty()) {
             profile = KoColorSpaceRegistry::instance()->profileByName(monitorProfileName);
         }
         if (profile) {
             //dbgKrita << "\t\tsuitable for display" << profile->isSuitableForDisplay();
         }
         else {
             //dbgKrita << "\t\tstill no profile";
         }
     }
     // if we still don't have a profile, or the profile isn't suitable for display,
     // we need to get a last-resort profile. the built-in sRGB is a good choice then.
     if (!profile || !profile->isSuitableForDisplay()) {
         //dbgKrita << "\tnothing worked, going to get sRGB built-in";
         profile = KoColorSpaceRegistry::instance()->profileByName("sRGB Built-in");
     }
 
     if (profile) {
         //dbgKrita << "\tKisConfig::displayProfile for screen" << screen << "is" << profile->name();
     }
     else {
         //dbgKrita << "\tCouldn't get a display profile at all";
     }
 
     return profile;
 }
 
 QString KisConfig::workingColorSpace(bool defaultValue) const
 {
     return (defaultValue ? "RGBA" : m_cfg.readEntry("workingColorSpace", "RGBA"));
 }
 
 void KisConfig::setWorkingColorSpace(const QString & workingColorSpace) const
 {
     m_cfg.writeEntry("workingColorSpace", workingColorSpace);
 }
 
 QString KisConfig::printerColorSpace(bool /*defaultValue*/) const
 {
     //TODO currently only rgb8 is supported
     //return (defaultValue ? "RGBA" : m_cfg.readEntry("printerColorSpace", "RGBA"));
     return QString("RGBA");
 }
 
 void KisConfig::setPrinterColorSpace(const QString & printerColorSpace) const
 {
     m_cfg.writeEntry("printerColorSpace", printerColorSpace);
 }
 
 
 QString KisConfig::printerProfile(bool defaultValue) const
 {
     return (defaultValue ? "" : m_cfg.readEntry("printerProfile", ""));
 }
 
 void KisConfig::setPrinterProfile(const QString & printerProfile) const
 {
     m_cfg.writeEntry("printerProfile", printerProfile);
 }
 
 
 bool KisConfig::useBlackPointCompensation(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useBlackPointCompensation", true));
 }
 
 void KisConfig::setUseBlackPointCompensation(bool useBlackPointCompensation) const
 {
     m_cfg.writeEntry("useBlackPointCompensation", useBlackPointCompensation);
 }
 
 bool KisConfig::allowLCMSOptimization(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("allowLCMSOptimization", true));
 }
 
 void KisConfig::setAllowLCMSOptimization(bool allowLCMSOptimization)
 {
     m_cfg.writeEntry("allowLCMSOptimization", allowLCMSOptimization);
 }
 
 bool KisConfig::forcePaletteColors(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("colorsettings/forcepalettecolors", false));
 }
 
 void KisConfig::setForcePaletteColors(bool forcePaletteColors)
 {
     m_cfg.writeEntry("colorsettings/forcepalettecolors", forcePaletteColors);
 }
 
 bool KisConfig::showRulers(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showrulers", false));
 }
 
 void KisConfig::setShowRulers(bool rulers) const
 {
     m_cfg.writeEntry("showrulers", rulers);
 }
 
 bool KisConfig::forceShowSaveMessages(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceShowSaveMessages", false));
 }
 
 void KisConfig::setForceShowSaveMessages(bool value) const
 {
     m_cfg.writeEntry("forceShowSaveMessages", value);
 }
 
 bool KisConfig::forceShowAutosaveMessages(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceShowAutosaveMessages", false));
 }
 
 void KisConfig::setForceShowAutosaveMessages(bool value) const
 {
     m_cfg.writeEntry("forceShowAutosaveMessages", value);
 }
 
 bool KisConfig::rulersTrackMouse(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("rulersTrackMouse", true));
 }
 
 void KisConfig::setRulersTrackMouse(bool value) const
 {
     m_cfg.writeEntry("rulersTrackMouse", value);
 }
 
 qint32 KisConfig::pasteBehaviour(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("pasteBehaviour", 2));
 }
 
 void KisConfig::setPasteBehaviour(qint32 renderIntent) const
 {
     m_cfg.writeEntry("pasteBehaviour", renderIntent);
 }
 
 
 qint32 KisConfig::monitorRenderIntent(bool defaultValue) const
 {
     qint32 intent = m_cfg.readEntry("renderIntent", INTENT_PERCEPTUAL);
     if (intent > 3) intent = 3;
     if (intent < 0) intent = 0;
     return (defaultValue ? INTENT_PERCEPTUAL : intent);
 }
 
 void KisConfig::setRenderIntent(qint32 renderIntent) const
 {
     if (renderIntent > 3) renderIntent = 3;
     if (renderIntent < 0) renderIntent = 0;
     m_cfg.writeEntry("renderIntent", renderIntent);
 }
 
 bool KisConfig::useOpenGL(bool defaultValue) const
 {
     if (defaultValue) {
         return true;
     }
 
-    //dbgKrita << "use opengl" << m_cfg.readEntry("useOpenGL", true) << "success" << m_cfg.readEntry("canvasState", "OPENGL_SUCCESS");
-    QString cs = canvasState();
-#ifdef Q_OS_WIN
-    return (m_cfg.readEntry("useOpenGLWindows", true) && (cs == "OPENGL_SUCCESS" || cs == "TRY_OPENGL"));
-#else
-    return (m_cfg.readEntry("useOpenGL", true) && (cs == "OPENGL_SUCCESS" || cs == "TRY_OPENGL"));
-#endif
+    const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
+    QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
+
+    return kritarc.value("OpenGLRenderer", "auto").toString() != "none";
 }
 
-void KisConfig::setUseOpenGL(bool useOpenGL) const
+void KisConfig::disableOpenGL() const
 {
-#ifdef Q_OS_WIN
-    m_cfg.writeEntry("useOpenGLWindows", useOpenGL);
-#else
-    m_cfg.writeEntry("useOpenGL", useOpenGL);
-#endif
+    const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
+    QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
+
+    kritarc.setValue("OpenGLRenderer", "none");
 }
 
 int KisConfig::openGLFilteringMode(bool defaultValue) const
 {
     return (defaultValue ? 3 : m_cfg.readEntry("OpenGLFilterMode", 3));
 }
 
 void KisConfig::setOpenGLFilteringMode(int filteringMode)
 {
     m_cfg.writeEntry("OpenGLFilterMode", filteringMode);
 }
 
 bool KisConfig::useOpenGLTextureBuffer(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useOpenGLTextureBuffer", true));
 }
 
 void KisConfig::setUseOpenGLTextureBuffer(bool useBuffer)
 {
     m_cfg.writeEntry("useOpenGLTextureBuffer", useBuffer);
 }
 
 int KisConfig::openGLTextureSize(bool defaultValue) const
 {
     return (defaultValue ? 256 : m_cfg.readEntry("textureSize", 256));
 }
 
 bool KisConfig::disableVSync(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("disableVSync", true));
 }
 
 void KisConfig::setDisableVSync(bool disableVSync)
 {
     m_cfg.writeEntry("disableVSync", disableVSync);
 }
 
 bool KisConfig::showAdvancedOpenGLSettings(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showAdvancedOpenGLSettings", false));
 }
 
 bool KisConfig::forceOpenGLFenceWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceOpenGLFenceWorkaround", false));
 }
 
 int KisConfig::numMipmapLevels(bool defaultValue) const
 {
     return (defaultValue ? 4 : m_cfg.readEntry("numMipmapLevels", 4));
 }
 
 int KisConfig::textureOverlapBorder() const
 {
     return 1 << qMax(0, numMipmapLevels());
 }
 
 quint32 KisConfig::getGridMainStyle(bool defaultValue) const
 {
     int v = m_cfg.readEntry("gridmainstyle", 0);
     v = qBound(0, v, 2);
     return (defaultValue ? 0 : v);
 }
 
 void KisConfig::setGridMainStyle(quint32 v) const
 {
     m_cfg.writeEntry("gridmainstyle", v);
 }
 
 quint32 KisConfig::getGridSubdivisionStyle(bool defaultValue) const
 {
     quint32 v = m_cfg.readEntry("gridsubdivisionstyle", 1);
     if (v > 2) v = 2;
     return (defaultValue ? 1 : v);
 }
 
 void KisConfig::setGridSubdivisionStyle(quint32 v) const
 {
     m_cfg.writeEntry("gridsubdivisionstyle", v);
 }
 
 QColor KisConfig::getGridMainColor(bool defaultValue) const
 {
     QColor col(99, 99, 99);
     return (defaultValue ? col : m_cfg.readEntry("gridmaincolor", col));
 }
 
 void KisConfig::setGridMainColor(const QColor & v) const
 {
     m_cfg.writeEntry("gridmaincolor", v);
 }
 
 QColor KisConfig::getGridSubdivisionColor(bool defaultValue) const
 {
     QColor col(150, 150, 150);
     return (defaultValue ? col : m_cfg.readEntry("gridsubdivisioncolor", col));
 }
 
 void KisConfig::setGridSubdivisionColor(const QColor & v) const
 {
     m_cfg.writeEntry("gridsubdivisioncolor", v);
 }
 
 QColor KisConfig::getPixelGridColor(bool defaultValue) const
 {
     QColor col(255, 255, 255);
     return (defaultValue ? col : m_cfg.readEntry("pixelGridColor", col));
 }
 
 void KisConfig::setPixelGridColor(const QColor & v) const
 {
     m_cfg.writeEntry("pixelGridColor", v);
 }
 
 qreal KisConfig::getPixelGridDrawingThreshold(bool defaultValue) const
 {
     qreal border = 24.0f;
     return (defaultValue ? border : m_cfg.readEntry("pixelGridDrawingThreshold", border));
 }
 
 void KisConfig::setPixelGridDrawingThreshold(qreal v) const
 {
     m_cfg.writeEntry("pixelGridDrawingThreshold", v);
 }
 
 bool KisConfig::pixelGridEnabled(bool defaultValue) const
 {
     bool enabled = true;
     return (defaultValue ? enabled : m_cfg.readEntry("pixelGridEnabled", enabled));
 }
 
 void KisConfig::enablePixelGrid(bool v) const
 {
     m_cfg.writeEntry("pixelGridEnabled", v);
 }
 
 quint32 KisConfig::guidesLineStyle(bool defaultValue) const
 {
     int v = m_cfg.readEntry("guidesLineStyle", 0);
     v = qBound(0, v, 2);
     return (defaultValue ? 0 : v);
 }
 
 void KisConfig::setGuidesLineStyle(quint32 v) const
 {
     m_cfg.writeEntry("guidesLineStyle", v);
 }
 
 QColor KisConfig::guidesColor(bool defaultValue) const
 {
     QColor col(99, 99, 99);
     return (defaultValue ? col : m_cfg.readEntry("guidesColor", col));
 }
 
 void KisConfig::setGuidesColor(const QColor & v) const
 {
     m_cfg.writeEntry("guidesColor", v);
 }
 
 void KisConfig::loadSnapConfig(KisSnapConfig *config, bool defaultValue) const
 {
     KisSnapConfig defaultConfig(false);
 
     if (defaultValue) {
         *config = defaultConfig;
         return;
     }
 
     config->setOrthogonal(m_cfg.readEntry("globalSnapOrthogonal", defaultConfig.orthogonal()));
     config->setNode(m_cfg.readEntry("globalSnapNode", defaultConfig.node()));
     config->setExtension(m_cfg.readEntry("globalSnapExtension", defaultConfig.extension()));
     config->setIntersection(m_cfg.readEntry("globalSnapIntersection", defaultConfig.intersection()));
     config->setBoundingBox(m_cfg.readEntry("globalSnapBoundingBox", defaultConfig.boundingBox()));
     config->setImageBounds(m_cfg.readEntry("globalSnapImageBounds", defaultConfig.imageBounds()));
     config->setImageCenter(m_cfg.readEntry("globalSnapImageCenter", defaultConfig.imageCenter()));
     config->setToPixel(m_cfg.readEntry("globalSnapToPixel", defaultConfig.toPixel()));
 }
 
 void KisConfig::saveSnapConfig(const KisSnapConfig &config)
 {
     m_cfg.writeEntry("globalSnapOrthogonal", config.orthogonal());
     m_cfg.writeEntry("globalSnapNode", config.node());
     m_cfg.writeEntry("globalSnapExtension", config.extension());
     m_cfg.writeEntry("globalSnapIntersection", config.intersection());
     m_cfg.writeEntry("globalSnapBoundingBox", config.boundingBox());
     m_cfg.writeEntry("globalSnapImageBounds", config.imageBounds());
     m_cfg.writeEntry("globalSnapImageCenter", config.imageCenter());
     m_cfg.writeEntry("globalSnapToPixel", config.toPixel());
 }
 
 qint32 KisConfig::checkSize(bool defaultValue) const
 {
     return (defaultValue ? 32 : m_cfg.readEntry("checksize", 32));
 }
 
 void KisConfig::setCheckSize(qint32 checksize) const
 {
     m_cfg.writeEntry("checksize", checksize);
 }
 
 bool KisConfig::scrollCheckers(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("scrollingcheckers", false));
 }
 
 void KisConfig::setScrollingCheckers(bool sc) const
 {
     m_cfg.writeEntry("scrollingcheckers", sc);
 }
 
 QColor KisConfig::canvasBorderColor(bool defaultValue) const
 {
     QColor color(QColor(128,128,128));
     return (defaultValue ? color : m_cfg.readEntry("canvasBorderColor", color));
 }
 
 void KisConfig::setCanvasBorderColor(const QColor& color) const
 {
     m_cfg.writeEntry("canvasBorderColor", color);
 }
 
 bool KisConfig::hideScrollbars(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("hideScrollbars", false));
 }
 
 void KisConfig::setHideScrollbars(bool value) const
 {
     m_cfg.writeEntry("hideScrollbars", value);
 }
 
 
 QColor KisConfig::checkersColor1(bool defaultValue) const
 {
     QColor col(220, 220, 220);
     return (defaultValue ? col : m_cfg.readEntry("checkerscolor", col));
 }
 
 void KisConfig::setCheckersColor1(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor", v);
 }
 
 QColor KisConfig::checkersColor2(bool defaultValue) const
 {
     return (defaultValue ? QColor(Qt::white) : m_cfg.readEntry("checkerscolor2", QColor(Qt::white)));
 }
 
 void KisConfig::setCheckersColor2(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor2", v);
 }
 
 bool KisConfig::antialiasCurves(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("antialiascurves", true));
 }
 
 void KisConfig::setAntialiasCurves(bool v) const
 {
     m_cfg.writeEntry("antialiascurves", v);
 }
 
 bool KisConfig::antialiasSelectionOutline(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("AntialiasSelectionOutline", false));
 }
 
 void KisConfig::setAntialiasSelectionOutline(bool v) const
 {
     m_cfg.writeEntry("AntialiasSelectionOutline", v);
 }
 
 bool KisConfig::showRootLayer(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ShowRootLayer", false));
 }
 
 void KisConfig::setShowRootLayer(bool showRootLayer) const
 {
     m_cfg.writeEntry("ShowRootLayer", showRootLayer);
 }
 
 bool KisConfig::showGlobalSelection(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ShowGlobalSelection", false));
 }
 
 void KisConfig::setShowGlobalSelection(bool showGlobalSelection) const
 {
     m_cfg.writeEntry("ShowGlobalSelection", showGlobalSelection);
 }
 
 bool KisConfig::showOutlineWhilePainting(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("ShowOutlineWhilePainting", true));
 }
 
 void KisConfig::setShowOutlineWhilePainting(bool showOutlineWhilePainting) const
 {
     m_cfg.writeEntry("ShowOutlineWhilePainting", showOutlineWhilePainting);
 }
 
 bool KisConfig::forceAlwaysFullSizedOutline(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceAlwaysFullSizedOutline", false));
 }
 
 void KisConfig::setForceAlwaysFullSizedOutline(bool value) const
 {
     m_cfg.writeEntry("forceAlwaysFullSizedOutline", value);
 }
 
 KisConfig::SessionOnStartup KisConfig::sessionOnStartup(bool defaultValue) const
 {
     int value = defaultValue ? SOS_BlankSession : m_cfg.readEntry("sessionOnStartup", (int)SOS_BlankSession);
     return (KisConfig::SessionOnStartup)value;
 }
 void KisConfig::setSessionOnStartup(SessionOnStartup value)
 {
     m_cfg.writeEntry("sessionOnStartup", (int)value);
 }
 
 bool KisConfig::saveSessionOnQuit(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("saveSessionOnQuit", false);
 }
 void KisConfig::setSaveSessionOnQuit(bool value)
 {
     m_cfg.writeEntry("saveSessionOnQuit", value);
 }
 
 qreal KisConfig::outlineSizeMinimum(bool defaultValue) const
 {
     return (defaultValue ? 1.0 : m_cfg.readEntry("OutlineSizeMinimum", 1.0));
 }
 
 void KisConfig::setOutlineSizeMinimum(qreal outlineSizeMinimum) const
 {
     m_cfg.writeEntry("OutlineSizeMinimum", outlineSizeMinimum);
 }
 
 qreal KisConfig::selectionViewSizeMinimum(bool defaultValue) const
 {
     return (defaultValue ? 5.0 : m_cfg.readEntry("SelectionViewSizeMinimum", 5.0));
 }
 
 void KisConfig::setSelectionViewSizeMinimum(qreal outlineSizeMinimum) const
 {
     m_cfg.writeEntry("SelectionViewSizeMinimum", outlineSizeMinimum);
 }
 
 int KisConfig::autoSaveInterval(bool defaultValue)  const
 {
     return (defaultValue ? 15 * 60 : m_cfg.readEntry("AutoSaveInterval", 15 * 60));
 }
 
 void KisConfig::setAutoSaveInterval(int seconds)  const
 {
     return m_cfg.writeEntry("AutoSaveInterval", seconds);
 }
 
 bool KisConfig::backupFile(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("CreateBackupFile", true));
 }
 
 void KisConfig::setBackupFile(bool backupFile) const
 {
     m_cfg.writeEntry("CreateBackupFile", backupFile);
 }
 
 bool KisConfig::showFilterGallery(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showFilterGallery", false));
 }
 
 void KisConfig::setShowFilterGallery(bool showFilterGallery) const
 {
     m_cfg.writeEntry("showFilterGallery", showFilterGallery);
 }
 
 bool KisConfig::showFilterGalleryLayerMaskDialog(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showFilterGalleryLayerMaskDialog", true));
 }
 
 void KisConfig::setShowFilterGalleryLayerMaskDialog(bool showFilterGallery) const
 {
     m_cfg.writeEntry("setShowFilterGalleryLayerMaskDialog", showFilterGallery);
 }
 
 QString KisConfig::canvasState(bool defaultValue) const
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     return (defaultValue ? "OPENGL_NOT_TRIED" : kritarc.value("canvasState", "OPENGL_NOT_TRIED").toString());
 }
 
 void KisConfig::setCanvasState(const QString& state) const
 {
     static QStringList acceptableStates;
     if (acceptableStates.isEmpty()) {
         acceptableStates << "OPENGL_SUCCESS" << "TRY_OPENGL" << "OPENGL_NOT_TRIED" << "OPENGL_FAILED";
     }
     if (acceptableStates.contains(state)) {
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("canvasState", state);
     }
 }
 
 bool KisConfig::toolOptionsPopupDetached(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ToolOptionsPopupDetached", false));
 }
 
 void KisConfig::setToolOptionsPopupDetached(bool detached) const
 {
     m_cfg.writeEntry("ToolOptionsPopupDetached", detached);
 }
 
 
 bool KisConfig::paintopPopupDetached(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("PaintopPopupDetached", false));
 }
 
 void KisConfig::setPaintopPopupDetached(bool detached) const
 {
     m_cfg.writeEntry("PaintopPopupDetached", detached);
 }
 
 QString KisConfig::pressureTabletCurve(bool defaultValue) const
 {
     return (defaultValue ? "0,0;1,1" : m_cfg.readEntry("tabletPressureCurve","0,0;1,1;"));
 }
 
 void KisConfig::setPressureTabletCurve(const QString& curveString) const
 {
     m_cfg.writeEntry("tabletPressureCurve", curveString);
 }
 
 bool KisConfig::useWin8PointerInput(bool defaultValue) const
 {
 #ifdef Q_OS_WIN
 #ifdef USE_QT_TABLET_WINDOWS
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     return useWin8PointerInputNoApp(&kritarc, defaultValue);
 #else
     return (defaultValue ? false : m_cfg.readEntry("useWin8PointerInput", false));
 #endif
 #else
     Q_UNUSED(defaultValue);
     return false;
 #endif
 }
 
 void KisConfig::setUseWin8PointerInput(bool value)
 {
 #ifdef Q_OS_WIN
 
     // Special handling: Only set value if changed
     // I don't want it to be set if the user hasn't touched it
     if (useWin8PointerInput() != value) {
 
 #ifdef USE_QT_TABLET_WINDOWS
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         setUseWin8PointerInputNoApp(&kritarc, value);
 #else
         m_cfg.writeEntry("useWin8PointerInput", value);
 #endif
 
     }
 
 #else
     Q_UNUSED(value)
 #endif
 }
 
 bool KisConfig::useWin8PointerInputNoApp(QSettings *settings, bool defaultValue)
 {
     return defaultValue ? false : settings->value("useWin8PointerInput", false).toBool();
 }
 
 void KisConfig::setUseWin8PointerInputNoApp(QSettings *settings, bool value)
 {
     settings->setValue("useWin8PointerInput", value);
 }
 
 bool KisConfig::useRightMiddleTabletButtonWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("useRightMiddleTabletButtonWorkaround", false));
 }
 
 void KisConfig::setUseRightMiddleTabletButtonWorkaround(bool value)
 {
     m_cfg.writeEntry("useRightMiddleTabletButtonWorkaround", value);
 }
 
 qreal KisConfig::vastScrolling(bool defaultValue) const
 {
     return (defaultValue ? 0.9 : m_cfg.readEntry("vastScrolling", 0.9));
 }
 
 void KisConfig::setVastScrolling(const qreal factor) const
 {
     m_cfg.writeEntry("vastScrolling", factor);
 }
 
 int KisConfig::presetChooserViewMode(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("presetChooserViewMode", 0));
 }
 
 void KisConfig::setPresetChooserViewMode(const int mode) const
 {
     m_cfg.writeEntry("presetChooserViewMode", mode);
 }
 
 int KisConfig::presetIconSize(bool defaultValue) const
 {
     return (defaultValue ? 60 : m_cfg.readEntry("presetIconSize", 60));
 }
 
 void KisConfig::setPresetIconSize(const int value) const
 {
     m_cfg.writeEntry("presetIconSize", value);
 }
 
 bool KisConfig::firstRun(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("firstRun", true));
 }
 
 void KisConfig::setFirstRun(const bool first) const
 {
     m_cfg.writeEntry("firstRun", first);
 }
 
 int KisConfig::horizontalSplitLines(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("horizontalSplitLines", 1));
 }
 void KisConfig::setHorizontalSplitLines(const int numberLines) const
 {
     m_cfg.writeEntry("horizontalSplitLines", numberLines);
 }
 
 int KisConfig::verticalSplitLines(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("verticalSplitLines", 1));
 }
 
 void KisConfig::setVerticalSplitLines(const int numberLines) const
 {
     m_cfg.writeEntry("verticalSplitLines", numberLines);
 }
 
 bool KisConfig::clicklessSpacePan(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("clicklessSpacePan", true));
 }
 
 void KisConfig::setClicklessSpacePan(const bool toggle) const
 {
     m_cfg.writeEntry("clicklessSpacePan", toggle);
 }
 
 
 bool KisConfig::hideDockersFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideDockersFullScreen", true));
 }
 
 void KisConfig::setHideDockersFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideDockersFullScreen", value);
 }
 
 bool KisConfig::showDockers(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showDockers", true));
 }
 
 void KisConfig::setShowDockers(const bool value) const
 {
     m_cfg.writeEntry("showDockers", value);
 }
 
 bool KisConfig::showStatusBar(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showStatusBar", true));
 }
 
 void KisConfig::setShowStatusBar(const bool value) const
 {
     m_cfg.writeEntry("showStatusBar", value);
 }
 
 bool KisConfig::hideMenuFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true: m_cfg.readEntry("hideMenuFullScreen", true));
 }
 
 void KisConfig::setHideMenuFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideMenuFullScreen", value);
 }
 
 bool KisConfig::hideScrollbarsFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideScrollbarsFullScreen", true));
 }
 
 void KisConfig::setHideScrollbarsFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideScrollbarsFullScreen", value);
 }
 
 bool KisConfig::hideStatusbarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true: m_cfg.readEntry("hideStatusbarFullScreen", true));
 }
 
 void KisConfig::setHideStatusbarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideStatusbarFullScreen", value);
 }
 
 bool KisConfig::hideTitlebarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideTitleBarFullscreen", true));
 }
 
 void KisConfig::setHideTitlebarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideTitleBarFullscreen", value);
 }
 
 bool KisConfig::hideToolbarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideToolbarFullscreen", true));
 }
 
 void KisConfig::setHideToolbarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideToolbarFullscreen", value);
 }
 
 bool KisConfig::fullscreenMode(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("fullscreenMode", true));
 }
 
 void KisConfig::setFullscreenMode(const bool value) const
 {
     m_cfg.writeEntry("fullscreenMode", value);
 }
 
 QStringList KisConfig::favoriteCompositeOps(bool defaultValue) const
 {
     return (defaultValue ? QStringList() :
                            m_cfg.readEntry("favoriteCompositeOps",
                                            QString("normal,erase,multiply,burn,darken,add,dodge,screen,overlay,soft_light_svg,luminize,lighten,saturation,color,divide").split(',')));
 }
 
 void KisConfig::setFavoriteCompositeOps(const QStringList& compositeOps) const
 {
     m_cfg.writeEntry("favoriteCompositeOps", compositeOps);
 }
 
 QString KisConfig::exportConfigurationXML(const QString &filterId, bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("ExportConfiguration-" + filterId, QString()));
 }
 
 KisPropertiesConfigurationSP KisConfig::exportConfiguration(const QString &filterId, bool defaultValue) const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     const QString xmlData = exportConfigurationXML(filterId, defaultValue);
     cfg->fromXML(xmlData);
     return cfg;
 }
 
 void KisConfig::setExportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const
 {
     QString exportConfig = properties->toXML();
     m_cfg.writeEntry("ExportConfiguration-" + filterId, exportConfig);
 }
 
 QString KisConfig::importConfiguration(const QString &filterId, bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("ImportConfiguration-" + filterId, QString()));
 }
 
 void KisConfig::setImportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const
 {
     QString importConfig = properties->toXML();
     m_cfg.writeEntry("ImportConfiguration-" + filterId, importConfig);
 }
 
 bool KisConfig::useOcio(bool defaultValue) const
 {
 #ifdef HAVE_OCIO
     return (defaultValue ? false : m_cfg.readEntry("Krita/Ocio/UseOcio", false));
 #else
     Q_UNUSED(defaultValue);
     return false;
 #endif
 }
 
 void KisConfig::setUseOcio(bool useOCIO) const
 {
     m_cfg.writeEntry("Krita/Ocio/UseOcio", useOCIO);
 }
 
 int KisConfig::favoritePresets(bool defaultValue) const
 {
     return (defaultValue ? 10 : m_cfg.readEntry("numFavoritePresets", 10));
 }
 
 void KisConfig::setFavoritePresets(const int value)
 {
     m_cfg.writeEntry("numFavoritePresets", value);
 }
 
 bool KisConfig::levelOfDetailEnabled(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("levelOfDetailEnabled", false));
 }
 
 void KisConfig::setLevelOfDetailEnabled(bool value)
 {
     m_cfg.writeEntry("levelOfDetailEnabled", value);
 }
 
 KisOcioConfiguration KisConfig::ocioConfiguration(bool defaultValue) const
 {
     KisOcioConfiguration cfg;
 
     if (!defaultValue) {
         cfg.mode = (KisOcioConfiguration::Mode)m_cfg.readEntry("Krita/Ocio/OcioColorManagementMode", 0);
         cfg.configurationPath = m_cfg.readEntry("Krita/Ocio/OcioConfigPath", QString());
         cfg.lutPath = m_cfg.readEntry("Krita/Ocio/OcioLutPath", QString());
         cfg.inputColorSpace = m_cfg.readEntry("Krita/Ocio/InputColorSpace", QString());
         cfg.displayDevice = m_cfg.readEntry("Krita/Ocio/DisplayDevice", QString());
         cfg.displayView = m_cfg.readEntry("Krita/Ocio/DisplayView", QString());
         cfg.look = m_cfg.readEntry("Krita/Ocio/DisplayLook", QString());
     }
 
     return cfg;
 }
 
 void KisConfig::setOcioConfiguration(const KisOcioConfiguration &cfg)
 {
     m_cfg.writeEntry("Krita/Ocio/OcioColorManagementMode", (int) cfg.mode);
     m_cfg.writeEntry("Krita/Ocio/OcioConfigPath", cfg.configurationPath);
     m_cfg.writeEntry("Krita/Ocio/OcioLutPath", cfg.lutPath);
     m_cfg.writeEntry("Krita/Ocio/InputColorSpace", cfg.inputColorSpace);
     m_cfg.writeEntry("Krita/Ocio/DisplayDevice", cfg.displayDevice);
     m_cfg.writeEntry("Krita/Ocio/DisplayView", cfg.displayView);
     m_cfg.writeEntry("Krita/Ocio/DisplayLook", cfg.look);
 }
 
 KisConfig::OcioColorManagementMode
 KisConfig::ocioColorManagementMode(bool defaultValue) const
 {
     // FIXME: this option duplicates ocioConfiguration(), please deprecate it
     return (OcioColorManagementMode)(defaultValue ? INTERNAL
                                                   : m_cfg.readEntry("Krita/Ocio/OcioColorManagementMode", (int) INTERNAL));
 }
 
 void KisConfig::setOcioColorManagementMode(OcioColorManagementMode mode) const
 {
     // FIXME: this option duplicates ocioConfiguration(), please deprecate it
     m_cfg.writeEntry("Krita/Ocio/OcioColorManagementMode", (int) mode);
 }
 
 int KisConfig::ocioLutEdgeSize(bool defaultValue) const
 {
     return (defaultValue ? 64 : m_cfg.readEntry("Krita/Ocio/LutEdgeSize", 64));
 }
 
 void KisConfig::setOcioLutEdgeSize(int value)
 {
     m_cfg.writeEntry("Krita/Ocio/LutEdgeSize", value);
 }
 
 bool KisConfig::ocioLockColorVisualRepresentation(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("Krita/Ocio/OcioLockColorVisualRepresentation", false));
 }
 
 void KisConfig::setOcioLockColorVisualRepresentation(bool value)
 {
     m_cfg.writeEntry("Krita/Ocio/OcioLockColorVisualRepresentation", value);
 }
 
 QString KisConfig::defaultPalette(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("defaultPalette", "Default"));
 }
 
 void KisConfig::setDefaultPalette(const QString& name) const
 {
     m_cfg.writeEntry("defaultPalette", name);
 }
 
 QString KisConfig::toolbarSlider(int sliderNumber, bool defaultValue) const
 {
     QString def = "flow";
     if (sliderNumber == 1) {
         def = "opacity";
     }
     if (sliderNumber == 2) {
         def = "size";
     }
     return (defaultValue ? def : m_cfg.readEntry(QString("toolbarslider_%1").arg(sliderNumber), def));
 }
 
 void KisConfig::setToolbarSlider(int sliderNumber, const QString &slider)
 {
     m_cfg.writeEntry(QString("toolbarslider_%1").arg(sliderNumber), slider);
 }
 
 int KisConfig::layerThumbnailSize(bool defaultValue) const
 {
     return (defaultValue ? 20 : m_cfg.readEntry("layerThumbnailSize", 20));
 }
 
 void KisConfig::setLayerThumbnailSize(int size)
 {
     m_cfg.writeEntry("layerThumbnailSize", size);
 }
 
 bool KisConfig::sliderLabels(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("sliderLabels", true));
 }
 
 void KisConfig::setSliderLabels(bool enabled)
 {
     m_cfg.writeEntry("sliderLabels", enabled);
 }
 
 QString KisConfig::currentInputProfile(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("currentInputProfile", QString()));
 }
 
 void KisConfig::setCurrentInputProfile(const QString& name)
 {
     m_cfg.writeEntry("currentInputProfile", name);
 }
 
 bool KisConfig::useSystemMonitorProfile(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ColorManagement/UseSystemMonitorProfile", false));
 }
 
 void KisConfig::setUseSystemMonitorProfile(bool _useSystemMonitorProfile) const
 {
     m_cfg.writeEntry("ColorManagement/UseSystemMonitorProfile", _useSystemMonitorProfile);
 }
 
 bool KisConfig::presetStripVisible(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("presetStripVisible", true));
 }
 
 void KisConfig::setPresetStripVisible(bool visible)
 {
     m_cfg.writeEntry("presetStripVisible", visible);
 }
 
 bool KisConfig::scratchpadVisible(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("scratchpadVisible", true));
 }
 
 void KisConfig::setScratchpadVisible(bool visible)
 {
     m_cfg.writeEntry("scratchpadVisible", visible);
 }
 
 bool KisConfig::showSingleChannelAsColor(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showSingleChannelAsColor", false));
 }
 
 void KisConfig::setShowSingleChannelAsColor(bool asColor)
 {
     m_cfg.writeEntry("showSingleChannelAsColor", asColor);
 }
 
 bool KisConfig::hidePopups(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("hidePopups", false));
 }
 
 void KisConfig::setHidePopups(bool hidepopups)
 {
     m_cfg.writeEntry("hidePopups", hidepopups);
 }
 
 int KisConfig::numDefaultLayers(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("NumberOfLayersForNewImage", 2));
 }
 
 void KisConfig::setNumDefaultLayers(int num)
 {
     m_cfg.writeEntry("NumberOfLayersForNewImage", num);
 }
 
 quint8 KisConfig::defaultBackgroundOpacity(bool defaultValue) const
 {
   return (defaultValue ? (int)OPACITY_OPAQUE_U8 : m_cfg.readEntry("BackgroundOpacityForNewImage", (int)OPACITY_OPAQUE_U8));
 }
 
 void KisConfig::setDefaultBackgroundOpacity(quint8 value)
 {
   m_cfg.writeEntry("BackgroundOpacityForNewImage", (int)value);
 }
 
 QColor KisConfig::defaultBackgroundColor(bool defaultValue) const
 {
   return (defaultValue ? QColor(Qt::white) : m_cfg.readEntry("BackgroundColorForNewImage", QColor(Qt::white)));
 }
 
 void KisConfig::setDefaultBackgroundColor(QColor value)
 {
   m_cfg.writeEntry("BackgroundColorForNewImage", value);
 }
 
 KisConfig::BackgroundStyle KisConfig::defaultBackgroundStyle(bool defaultValue) const
 {
   return (KisConfig::BackgroundStyle)(defaultValue ? RASTER_LAYER : m_cfg.readEntry("BackgroundStyleForNewImage", (int)RASTER_LAYER));
 }
 
 void KisConfig::setDefaultBackgroundStyle(KisConfig::BackgroundStyle value)
 {
   m_cfg.writeEntry("BackgroundStyleForNewImage", (int)value);
 }
 
 int KisConfig::lineSmoothingType(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("LineSmoothingType", 1));
 }
 
 void KisConfig::setLineSmoothingType(int value)
 {
     m_cfg.writeEntry("LineSmoothingType", value);
 }
 
 qreal KisConfig::lineSmoothingDistance(bool defaultValue) const
 {
     return (defaultValue ? 50.0 : m_cfg.readEntry("LineSmoothingDistance", 50.0));
 }
 
 void KisConfig::setLineSmoothingDistance(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingDistance", value);
 }
 
 qreal KisConfig::lineSmoothingTailAggressiveness(bool defaultValue) const
 {
     return (defaultValue ? 0.15 : m_cfg.readEntry("LineSmoothingTailAggressiveness", 0.15));
 }
 
 void KisConfig::setLineSmoothingTailAggressiveness(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingTailAggressiveness", value);
 }
 
 bool KisConfig::lineSmoothingSmoothPressure(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("LineSmoothingSmoothPressure", false));
 }
 
 void KisConfig::setLineSmoothingSmoothPressure(bool value)
 {
     m_cfg.writeEntry("LineSmoothingSmoothPressure", value);
 }
 
 bool KisConfig::lineSmoothingScalableDistance(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingScalableDistance", true));
 }
 
 void KisConfig::setLineSmoothingScalableDistance(bool value)
 {
     m_cfg.writeEntry("LineSmoothingScalableDistance", value);
 }
 
 qreal KisConfig::lineSmoothingDelayDistance(bool defaultValue) const
 {
     return (defaultValue ? 50.0 : m_cfg.readEntry("LineSmoothingDelayDistance", 50.0));
 }
 
 void KisConfig::setLineSmoothingDelayDistance(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingDelayDistance", value);
 }
 
 bool KisConfig::lineSmoothingUseDelayDistance(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingUseDelayDistance", true));
 }
 
 void KisConfig::setLineSmoothingUseDelayDistance(bool value)
 {
     m_cfg.writeEntry("LineSmoothingUseDelayDistance", value);
 }
 
 bool KisConfig::lineSmoothingFinishStabilizedCurve(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingFinishStabilizedCurve", true));
 }
 
 void KisConfig::setLineSmoothingFinishStabilizedCurve(bool value)
 {
     m_cfg.writeEntry("LineSmoothingFinishStabilizedCurve", value);
 }
 
 bool KisConfig::lineSmoothingStabilizeSensors(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingStabilizeSensors", true));
 }
 
 void KisConfig::setLineSmoothingStabilizeSensors(bool value)
 {
     m_cfg.writeEntry("LineSmoothingStabilizeSensors", value);
 }
 
 int KisConfig::tabletEventsDelay(bool defaultValue) const
 {
     return (defaultValue ? 10 : m_cfg.readEntry("tabletEventsDelay", 10));
 }
 
 void KisConfig::setTabletEventsDelay(int value)
 {
     m_cfg.writeEntry("tabletEventsDelay", value);
 }
 
 bool KisConfig::trackTabletEventLatency(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("trackTabletEventLatency", false));
 }
 
 void KisConfig::setTrackTabletEventLatency(bool value)
 {
     m_cfg.writeEntry("trackTabletEventLatency", value);
 }
 
 bool KisConfig::testingAcceptCompressedTabletEvents(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("testingAcceptCompressedTabletEvents", false));
 }
 
 void KisConfig::setTestingAcceptCompressedTabletEvents(bool value)
 {
     m_cfg.writeEntry("testingAcceptCompressedTabletEvents", value);
 }
 
 bool KisConfig::shouldEatDriverShortcuts(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("shouldEatDriverShortcuts", false));
 }
 
 bool KisConfig::testingCompressBrushEvents(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("testingCompressBrushEvents", false));
 }
 
 void KisConfig::setTestingCompressBrushEvents(bool value)
 {
     m_cfg.writeEntry("testingCompressBrushEvents", value);
 }
 
 int KisConfig::workaroundX11SmoothPressureSteps(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("workaroundX11SmoothPressureSteps", 0));
 }
 
 bool KisConfig::showCanvasMessages(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showOnCanvasMessages", true));
 }
 
 void KisConfig::setShowCanvasMessages(bool show)
 {
     m_cfg.writeEntry("showOnCanvasMessages", show);
 }
 
 bool KisConfig::compressKra(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("compressLayersInKra", false));
 }
 
 void KisConfig::setCompressKra(bool compress)
 {
     m_cfg.writeEntry("compressLayersInKra", compress);
 }
 
 bool KisConfig::toolOptionsInDocker(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("ToolOptionsInDocker", true));
 }
 
 void KisConfig::setToolOptionsInDocker(bool inDocker)
 {
     m_cfg.writeEntry("ToolOptionsInDocker", inDocker);
 }
 
 bool KisConfig::kineticScrollingEnabled(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("KineticScrollingEnabled", true));
 }
 
 void KisConfig::setKineticScrollingEnabled(bool value)
 {
     m_cfg.writeEntry("KineticScrollingEnabled", value);
 }
 
 int KisConfig::kineticScrollingGesture(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("KineticScrollingGesture", 2));
 }
 
 void KisConfig::setKineticScrollingGesture(int gesture)
 {
     m_cfg.writeEntry("KineticScrollingGesture", gesture);
 }
 
 int KisConfig::kineticScrollingSensitivity(bool defaultValue) const
 {
     return (defaultValue ? 75 : m_cfg.readEntry("KineticScrollingSensitivity", 75));
 }
 
 void KisConfig::setKineticScrollingSensitivity(int sensitivity)
 {
     m_cfg.writeEntry("KineticScrollingSensitivity", sensitivity);
 }
 
 bool KisConfig::kineticScrollingHiddenScrollbars(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("KineticScrollingHideScrollbar", false));
 }
 
 void KisConfig::setKineticScrollingHideScrollbars(bool scrollbar)
 {
     m_cfg.writeEntry("KineticScrollingHideScrollbar", scrollbar);
 }
 
 const KoColorSpace* KisConfig::customColorSelectorColorSpace(bool defaultValue) const
 {
     const KoColorSpace *cs = 0;
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     if (defaultValue || cfg.readEntry("useCustomColorSpace", true)) {
         KoColorSpaceRegistry* csr = KoColorSpaceRegistry::instance();
         QString modelID = cfg.readEntry("customColorSpaceModel", "RGBA");
         QString depthID = cfg.readEntry("customColorSpaceDepthID", "U8");
         QString profile = cfg.readEntry("customColorSpaceProfile", "sRGB built-in - (lcms internal)");
         if (profile == "default") {
           // qDebug() << "Falling back to default color profile.";
           profile = "sRGB built-in - (lcms internal)";
         }
         cs = csr->colorSpace(modelID, depthID, profile);
     }
 
     return cs;
 }
 
 void KisConfig::setCustomColorSelectorColorSpace(const KoColorSpace *cs)
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     cfg.writeEntry("useCustomColorSpace", bool(cs));
     if(cs) {
         cfg.writeEntry("customColorSpaceModel", cs->colorModelId().id());
         cfg.writeEntry("customColorSpaceDepthID", cs->colorDepthId().id());
         cfg.writeEntry("customColorSpaceProfile", cs->profile()->name());
     }
 
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::enableOpenGLFramerateLogging(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("enableOpenGLFramerateLogging", false));
 }
 
 void KisConfig::setEnableOpenGLFramerateLogging(bool value) const
 {
     m_cfg.writeEntry("enableOpenGLFramerateLogging", value);
 }
 
 bool KisConfig::enableBrushSpeedLogging(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("enableBrushSpeedLogging", false));
 }
 
 void KisConfig::setEnableBrushSpeedLogging(bool value) const
 {
     m_cfg.writeEntry("enableBrushSpeedLogging", value);
 }
 
 void KisConfig::setEnableAmdVectorizationWorkaround(bool value)
 {
     m_cfg.writeEntry("amdDisableVectorWorkaround", value);
 }
 
 bool KisConfig::enableAmdVectorizationWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("amdDisableVectorWorkaround", false));
 }
 
 void KisConfig::setDisableAVXOptimizations(bool value)
 {
     m_cfg.writeEntry("disableAVXOptimizations", value);
 }
 
 bool KisConfig::disableAVXOptimizations(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("disableAVXOptimizations", false));
 }
 
 void KisConfig::setAnimationDropFrames(bool value)
 {
     bool oldValue = animationDropFrames();
 
     if (value == oldValue) return;
 
     m_cfg.writeEntry("animationDropFrames", value);
     KisConfigNotifier::instance()->notifyDropFramesModeChanged();
 }
 
 bool KisConfig::animationDropFrames(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("animationDropFrames", true));
 }
 
 int KisConfig::scrubbingUpdatesDelay(bool defaultValue) const
 {
     return (defaultValue ? 30 : m_cfg.readEntry("scrubbingUpdatesDelay", 30));
 }
 
 void KisConfig::setScrubbingUpdatesDelay(int value)
 {
     m_cfg.writeEntry("scrubbingUpdatesDelay", value);
 }
 
 int KisConfig::scrubbingAudioUpdatesDelay(bool defaultValue) const
 {
     return (defaultValue ? -1 : m_cfg.readEntry("scrubbingAudioUpdatesDelay", -1));
 }
 
 void KisConfig::setScrubbingAudioUpdatesDelay(int value)
 {
     m_cfg.writeEntry("scrubbingAudioUpdatesDelay", value);
 }
 
 int KisConfig::audioOffsetTolerance(bool defaultValue) const
 {
     return (defaultValue ? -1 : m_cfg.readEntry("audioOffsetTolerance", -1));
 }
 
 void KisConfig::setAudioOffsetTolerance(int value)
 {
     m_cfg.writeEntry("audioOffsetTolerance", value);
 }
 
 bool KisConfig::switchSelectionCtrlAlt(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("switchSelectionCtrlAlt", false);
 }
 
 void KisConfig::setSwitchSelectionCtrlAlt(bool value)
 {
     m_cfg.writeEntry("switchSelectionCtrlAlt", value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::convertToImageColorspaceOnImport(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("ConvertToImageColorSpaceOnImport", false);
 }
 
 void KisConfig::setConvertToImageColorspaceOnImport(bool value)
 {
     m_cfg.writeEntry("ConvertToImageColorSpaceOnImport", value);
 }
 
 int KisConfig::stabilizerSampleSize(bool defaultValue) const
 {
 #ifdef Q_OS_WIN
     const int defaultSampleSize = 50;
 #else
     const int defaultSampleSize = 15;
 #endif
 
     return defaultValue ?
         defaultSampleSize : m_cfg.readEntry("stabilizerSampleSize", defaultSampleSize);
 }
 
 void KisConfig::setStabilizerSampleSize(int value)
 {
     m_cfg.writeEntry("stabilizerSampleSize", value);
 }
 
 bool KisConfig::stabilizerDelayedPaint(bool defaultValue) const
 {
     const bool defaultEnabled = true;
 
     return defaultValue ?
         defaultEnabled : m_cfg.readEntry("stabilizerDelayedPaint", defaultEnabled);
 }
 
 void KisConfig::setStabilizerDelayedPaint(bool value)
 {
     m_cfg.writeEntry("stabilizerDelayedPaint", value);
 }
 
 bool KisConfig::showBrushHud(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("showBrushHud", false);
 }
 
 void KisConfig::setShowBrushHud(bool value)
 {
     m_cfg.writeEntry("showBrushHud", value);
 }
 
 QString KisConfig::brushHudSetting(bool defaultValue) const
 {
     QString defaultDoc = "<!DOCTYPE hud_properties>\n<hud_properties>\n <version value=\"1\" type=\"value\"/>\n <paintbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"angle\" type=\"value\"/>\n  </properties_list>\n </paintbrush>\n <colorsmudge>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"smudge_mode\" type=\"value\"/>\n   <item_3 value=\"smudge_length\" type=\"value\"/>\n   <item_4 value=\"smudge_color_rate\" type=\"value\"/>\n  </properties_list>\n </colorsmudge>\n <sketchbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"size\" type=\"value\"/>\n  </properties_list>\n </sketchbrush>\n <hairybrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </hairybrush>\n <experimentbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"shape_windingfill\" type=\"value\"/>\n  </properties_list>\n </experimentbrush>\n <spraybrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"spray_particlecount\" type=\"value\"/>\n   <item_3 value=\"spray_density\" type=\"value\"/>\n  </properties_list>\n </spraybrush>\n <hatchingbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"hatching_angle\" type=\"value\"/>\n   <item_3 value=\"hatching_thickness\" type=\"value\"/>\n   <item_4 value=\"hatching_separation\" type=\"value\"/>\n  </properties_list>\n </hatchingbrush>\n <gridbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"grid_divisionlevel\" type=\"value\"/>\n  </properties_list>\n </gridbrush>\n <curvebrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"curve_historysize\" type=\"value\"/>\n   <item_2 value=\"curve_linewidth\" type=\"value\"/>\n   <item_3 value=\"curve_lineopacity\" type=\"value\"/>\n   <item_4 value=\"curve_connectionline\" type=\"value\"/>\n  </properties_list>\n </curvebrush>\n <dynabrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"dyna_diameter\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"dyna_mass\" type=\"value\"/>\n   <item_3 value=\"dyna_drag\" type=\"value\"/>\n  </properties_list>\n </dynabrush>\n <particlebrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"particle_particles\" type=\"value\"/>\n   <item_2 value=\"particle_opecityweight\" type=\"value\"/>\n   <item_3 value=\"particle_iterations\" type=\"value\"/>\n  </properties_list>\n </particlebrush>\n <duplicate>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"clone_healing\" type=\"value\"/>\n   <item_3 value=\"clone_movesource\" type=\"value\"/>\n  </properties_list>\n </duplicate>\n <deformbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"deform_amount\" type=\"value\"/>\n   <item_3 value=\"deform_mode\" type=\"value\"/>\n  </properties_list>\n </deformbrush>\n <tangentnormal>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </tangentnormal>\n <filter>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </filter>\n <roundmarker>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"size\" type=\"value\"/>\n  </properties_list>\n </roundmarker>\n</hud_properties>\n";
     return defaultValue ? defaultDoc : m_cfg.readEntry("brushHudSettings", defaultDoc);
 }
 
 void KisConfig::setBrushHudSetting(const QString &value) const
 {
     m_cfg.writeEntry("brushHudSettings", value);
 }
 
 bool KisConfig::calculateAnimationCacheInBackground(bool defaultValue) const
 {
     return defaultValue ? true : m_cfg.readEntry("calculateAnimationCacheInBackground", true);
 }
 
 void KisConfig::setCalculateAnimationCacheInBackground(bool value)
 {
     m_cfg.writeEntry("calculateAnimationCacheInBackground", value);
 }
 
 QColor KisConfig::defaultAssistantsColor(bool defaultValue) const
 {
     static const QColor defaultColor = QColor(176, 176, 176, 255);
     return defaultValue ? defaultColor : m_cfg.readEntry("defaultAssistantsColor", defaultColor);
 }
 
 void KisConfig::setDefaultAssistantsColor(const QColor &color) const
 {
     m_cfg.writeEntry("defaultAssistantsColor", color);
 }
 
 bool KisConfig::autoSmoothBezierCurves(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("autoSmoothBezierCurves", false);
 }
 
 void KisConfig::setAutoSmoothBezierCurves(bool value)
 {
     m_cfg.writeEntry("autoSmoothBezierCurves", value);
 }
 
 bool KisConfig::activateTransformToolAfterPaste(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("activateTransformToolAfterPaste", false);
 }
 
 void KisConfig::setActivateTransformToolAfterPaste(bool value)
 {
     m_cfg.writeEntry("activateTransformToolAfterPaste", value);
 }
 
 KisConfig::RootSurfaceFormat KisConfig::rootSurfaceFormat(bool defaultValue) const
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     return rootSurfaceFormat(&kritarc, defaultValue);
 }
 
 void KisConfig::setRootSurfaceFormat(KisConfig::RootSurfaceFormat value)
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     setRootSurfaceFormat(&kritarc, value);
 }
 
 KisConfig::RootSurfaceFormat KisConfig::rootSurfaceFormat(QSettings *displayrc, bool defaultValue)
 {
     QString textValue = "bt709-g22";
 
     if (!defaultValue) {
         textValue = displayrc->value("rootSurfaceFormat", textValue).toString();
     }
 
     return textValue == "bt709-g10" ? BT709_G10 :
            textValue == "bt2020-pq" ? BT2020_PQ :
            BT709_G22;
 }
 
 void KisConfig::setRootSurfaceFormat(QSettings *displayrc, KisConfig::RootSurfaceFormat value)
 {
     const QString textValue =
         value == BT709_G10 ? "bt709-g10" :
         value == BT2020_PQ ? "bt2020-pq" :
         "bt709-g22";
 
     displayrc->setValue("rootSurfaceFormat", textValue);
 }
 
 bool KisConfig::useZip64(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("UseZip64", false);
 }
 
 void KisConfig::setUseZip64(bool value)
 {
     m_cfg.writeEntry("UseZip64", value);
 }
 
 #include <QDomDocument>
 #include <QDomElement>
 
 void KisConfig::writeKoColor(const QString& name, const KoColor& color) const
 {
     QDomDocument doc = QDomDocument(name);
     QDomElement el = doc.createElement(name);
     doc.appendChild(el);
     color.toXML(doc, el);
     m_cfg.writeEntry(name, doc.toString());
 }
 
 //ported from kispropertiesconfig.
 KoColor KisConfig::readKoColor(const QString& name, const KoColor& color) const
 {
     QDomDocument doc;
     if (!m_cfg.readEntry(name).isNull()) {
         doc.setContent(m_cfg.readEntry(name));
         QDomElement e = doc.documentElement().firstChild().toElement();
         return KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     } else {
         QString blackColor = "<!DOCTYPE Color>\n<Color>\n <RGB r=\"0\" space=\"sRGB-elle-V2-srgbtrc.icc\" b=\"0\" g=\"0\"/>\n</Color>\n";
         doc.setContent(blackColor);
         QDomElement e = doc.documentElement().firstChild().toElement();
         return KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     }
     return color;
 
 }
diff --git a/libs/ui/kis_config.h b/libs/ui/kis_config.h
index ea97177a09..2ac7ed0436 100644
--- a/libs/ui/kis_config.h
+++ b/libs/ui/kis_config.h
@@ -1,636 +1,636 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_CONFIG_H_
 #define KIS_CONFIG_H_
 
 #include <QString>
 #include <QStringList>
 #include <QList>
 #include <QColor>
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <kis_global.h>
 #include <kis_properties_configuration.h>
 #include "kritaui_export.h"
 
 class KoColorProfile;
 class KoColorSpace;
 class KisSnapConfig;
 class QSettings;
 class KisOcioConfiguration;
 
 class KRITAUI_EXPORT KisConfig
 {
 public:
     /**
      * @brief KisConfig create a kisconfig object
      * @param readOnly if true, there will be no call to sync when the object is deleted.
      *  Any KisConfig object created in a thread must be read-only.
      */
     KisConfig(bool readOnly);
 
     ~KisConfig();
 
     bool disableTouchOnCanvas(bool defaultValue = false) const;
     void setDisableTouchOnCanvas(bool value) const;
 
     bool useProjections(bool defaultValue = false) const;
     void setUseProjections(bool useProj) const;
 
     bool undoEnabled(bool defaultValue = false) const;
     void setUndoEnabled(bool undo) const;
 
     int undoStackLimit(bool defaultValue = false) const;
     void setUndoStackLimit(int limit) const;
 
     bool useCumulativeUndoRedo(bool defaultValue = false) const;
     void setCumulativeUndoRedo(bool value);
 
     double stackT1(bool defaultValue = false) const;
     void setStackT1(int T1);
 
     double stackT2(bool defaultValue = false) const;
     void setStackT2(int T2);
 
     int stackN(bool defaultValue = false) const;
     void setStackN(int N);
 
     qint32 defImageWidth(bool defaultValue = false) const;
     void defImageWidth(qint32 width) const;
 
     qint32 defImageHeight(bool defaultValue = false) const;
     void defImageHeight(qint32 height) const;
 
     qreal defImageResolution(bool defaultValue = false) const;
     void defImageResolution(qreal res) const;
 
     int preferredVectorImportResolutionPPI(bool defaultValue = false) const;
     void setPreferredVectorImportResolutionPPI(int value) const;
 
     /**
      * @return the id of the default color model used for creating new images.
      */
     QString defColorModel(bool defaultValue = false) const;
     /**
      * set the id of the default color model used for creating new images.
      */
     void defColorModel(const QString & model) const;
 
     /**
      * @return the id of the default color depth used for creating new images.
      */
     QString defaultColorDepth(bool defaultValue = false) const;
     /**
      * set the id of the default color depth used for creating new images.
      */
     void setDefaultColorDepth(const QString & depth) const;
 
     /**
      * @return the id of the default color profile used for creating new images.
      */
     QString defColorProfile(bool defaultValue = false) const;
     /**
      * set the id of the default color profile used for creating new images.
      */
     void defColorProfile(const QString & depth) const;
 
     CursorStyle newCursorStyle(bool defaultValue = false) const;
     void setNewCursorStyle(CursorStyle style);
 
     QColor getCursorMainColor(bool defaultValue = false) const;
     void setCursorMainColor(const QColor& v) const;
 
     OutlineStyle newOutlineStyle(bool defaultValue = false) const;
     void setNewOutlineStyle(OutlineStyle style);
 
     QRect colorPreviewRect() const;
     void setColorPreviewRect(const QRect &rect);
 
     /// get the profile the user has selected for the given screen
     QString monitorProfile(int screen) const;
     void setMonitorProfile(int screen, const QString & monitorProfile, bool override) const;
 
     QString monitorForScreen(int screen, const QString &defaultMonitor, bool defaultValue = true) const;
     void setMonitorForScreen(int screen, const QString& monitor);
 
     /// Get the actual profile to be used for the given screen, which is
     /// either the screen profile set by the color management system or
     /// the custom monitor profile set by the user, depending on the configuration
     const KoColorProfile *displayProfile(int screen) const;
 
     QString workingColorSpace(bool defaultValue = false) const;
     void setWorkingColorSpace(const QString & workingColorSpace) const;
 
     QString importProfile(bool defaultValue = false) const;
     void setImportProfile(const QString & importProfile) const;
 
     QString printerColorSpace(bool defaultValue = false) const;
     void setPrinterColorSpace(const QString & printerColorSpace) const;
 
     QString printerProfile(bool defaultValue = false) const;
     void setPrinterProfile(const QString & printerProfile) const;
 
     bool useBlackPointCompensation(bool defaultValue = false) const;
     void setUseBlackPointCompensation(bool useBlackPointCompensation) const;
 
     bool allowLCMSOptimization(bool defaultValue = false) const;
     void setAllowLCMSOptimization(bool allowLCMSOptimization);
 
     bool forcePaletteColors(bool defaultValue = false) const;
     void setForcePaletteColors(bool forcePaletteColors);
 
     void writeKoColor(const QString& name, const KoColor& color) const;
     KoColor readKoColor(const QString& name, const KoColor& color = KoColor()) const;
 
     bool showRulers(bool defaultValue = false) const;
     void setShowRulers(bool rulers) const;
 
     bool forceShowSaveMessages(bool defaultValue = true) const;
     void setForceShowSaveMessages(bool value) const;
 
     bool forceShowAutosaveMessages(bool defaultValue = true) const;
     void setForceShowAutosaveMessages(bool ShowAutosaveMessages) const;
 
     bool rulersTrackMouse(bool defaultValue = false) const;
     void setRulersTrackMouse(bool value) const;
 
     qint32 pasteBehaviour(bool defaultValue = false) const;
     void setPasteBehaviour(qint32 behaviour) const;
 
     qint32 monitorRenderIntent(bool defaultValue = false) const;
     void setRenderIntent(qint32 monitorRenderIntent) const;
 
     bool useOpenGL(bool defaultValue = false) const;
-    void setUseOpenGL(bool useOpenGL) const;
+    void disableOpenGL() const;
 
     int openGLFilteringMode(bool defaultValue = false) const;
     void setOpenGLFilteringMode(int filteringMode);
 
     bool useOpenGLTextureBuffer(bool defaultValue = false) const;
     void setUseOpenGLTextureBuffer(bool useBuffer);
 
     bool disableVSync(bool defaultValue = false) const;
     void setDisableVSync(bool disableVSync);
 
     bool showAdvancedOpenGLSettings(bool defaultValue = false) const;
 
     bool forceOpenGLFenceWorkaround(bool defaultValue = false) const;
 
     int numMipmapLevels(bool defaultValue = false) const;
     int openGLTextureSize(bool defaultValue = false) const;
     int textureOverlapBorder() const;
 
     quint32 getGridMainStyle(bool defaultValue = false) const;
     void setGridMainStyle(quint32 v) const;
 
     quint32 getGridSubdivisionStyle(bool defaultValue = false) const;
     void setGridSubdivisionStyle(quint32 v) const;
 
     QColor getGridMainColor(bool defaultValue = false) const;
     void setGridMainColor(const QColor & v) const;
 
     QColor getGridSubdivisionColor(bool defaultValue = false) const;
     void setGridSubdivisionColor(const QColor & v) const;
 
     QColor getPixelGridColor(bool defaultValue = false) const;
     void setPixelGridColor(const QColor & v) const;
 
     qreal getPixelGridDrawingThreshold(bool defaultValue = false) const;
     void setPixelGridDrawingThreshold(qreal v) const;
 
     bool pixelGridEnabled(bool defaultValue = false) const;
     void enablePixelGrid(bool v) const;
 
     quint32 guidesLineStyle(bool defaultValue = false) const;
     void setGuidesLineStyle(quint32 v) const;
     QColor guidesColor(bool defaultValue = false) const;
     void setGuidesColor(const QColor & v) const;
 
     void loadSnapConfig(KisSnapConfig *config, bool defaultValue = false) const;
     void saveSnapConfig(const KisSnapConfig &config);
 
     qint32 checkSize(bool defaultValue = false) const;
     void setCheckSize(qint32 checkSize) const;
 
     bool scrollCheckers(bool defaultValue = false) const;
     void setScrollingCheckers(bool scollCheckers) const;
 
     QColor checkersColor1(bool defaultValue = false) const;
     void setCheckersColor1(const QColor & v) const;
 
     QColor checkersColor2(bool defaultValue = false) const;
     void setCheckersColor2(const QColor & v) const;
 
     QColor canvasBorderColor(bool defaultValue = false) const;
     void setCanvasBorderColor(const QColor &color) const;
 
     bool hideScrollbars(bool defaultValue = false) const;
     void setHideScrollbars(bool value) const;
 
     bool antialiasCurves(bool defaultValue = false) const;
     void setAntialiasCurves(bool v) const;
 
     bool antialiasSelectionOutline(bool defaultValue = false) const;
     void setAntialiasSelectionOutline(bool v) const;
 
     bool showRootLayer(bool defaultValue = false) const;
     void setShowRootLayer(bool showRootLayer) const;
 
     bool showGlobalSelection(bool defaultValue = false) const;
     void setShowGlobalSelection(bool showGlobalSelection) const;
 
     bool showOutlineWhilePainting(bool defaultValue = false) const;
     void setShowOutlineWhilePainting(bool showOutlineWhilePainting) const;
 
     bool forceAlwaysFullSizedOutline(bool defaultValue = false) const;
     void setForceAlwaysFullSizedOutline(bool value) const;
 
     enum SessionOnStartup {
         SOS_BlankSession,
         SOS_PreviousSession,
         SOS_ShowSessionManager
     };
     SessionOnStartup sessionOnStartup(bool defaultValue = false) const;
     void setSessionOnStartup(SessionOnStartup value);
 
     bool saveSessionOnQuit(bool defaultValue) const;
     void setSaveSessionOnQuit(bool value);
 
     qreal outlineSizeMinimum(bool defaultValue = false) const;
     void setOutlineSizeMinimum(qreal outlineSizeMinimum) const;
 
     qreal selectionViewSizeMinimum(bool defaultValue = false) const;
     void setSelectionViewSizeMinimum(qreal outlineSizeMinimum) const;
 
     int autoSaveInterval(bool defaultValue = false) const;
     void setAutoSaveInterval(int seconds) const;
 
     bool backupFile(bool defaultValue = false) const;
     void setBackupFile(bool backupFile) const;
 
     bool showFilterGallery(bool defaultValue = false) const;
     void setShowFilterGallery(bool showFilterGallery) const;
 
     bool showFilterGalleryLayerMaskDialog(bool defaultValue = false) const;
     void setShowFilterGalleryLayerMaskDialog(bool showFilterGallery) const;
 
     // OPENGL_SUCCESS, TRY_OPENGL, OPENGL_NOT_TRIED, OPENGL_FAILED
     QString canvasState(bool defaultValue = false) const;
     void setCanvasState(const QString& state) const;
 
     bool toolOptionsPopupDetached(bool defaultValue = false) const;
     void setToolOptionsPopupDetached(bool detached) const;
 
     bool paintopPopupDetached(bool defaultValue = false) const;
     void setPaintopPopupDetached(bool detached) const;
 
     QString pressureTabletCurve(bool defaultValue = false) const;
     void setPressureTabletCurve(const QString& curveString) const;
 
     bool useWin8PointerInput(bool defaultValue = false) const;
     void setUseWin8PointerInput(bool value);
 
     static bool useWin8PointerInputNoApp(QSettings *settings, bool defaultValue = false);
     static void setUseWin8PointerInputNoApp(QSettings *settings, bool value);
 
     bool useRightMiddleTabletButtonWorkaround(bool defaultValue = false) const;
     void setUseRightMiddleTabletButtonWorkaround(bool value);
 
     qreal vastScrolling(bool defaultValue = false) const;
     void setVastScrolling(const qreal factor) const;
 
     int presetChooserViewMode(bool defaultValue = false) const;
     void setPresetChooserViewMode(const int mode) const;
 
     int presetIconSize(bool defaultValue = false) const;
     void setPresetIconSize(const int value) const;
 
 
     bool firstRun(bool defaultValue = false) const;
     void setFirstRun(const bool firstRun) const;
 
     bool clicklessSpacePan(bool defaultValue = false) const;
     void setClicklessSpacePan(const bool toggle) const;
 
     int horizontalSplitLines(bool defaultValue = false) const;
     void setHorizontalSplitLines(const int numberLines) const;
 
     int verticalSplitLines(bool defaultValue = false) const;
     void setVerticalSplitLines(const int numberLines) const;
 
     bool hideDockersFullscreen(bool defaultValue = false) const;
     void setHideDockersFullscreen(const bool value) const;
 
     bool showDockers(bool defaultValue = false) const;
     void setShowDockers(const bool value) const;
 
     bool showStatusBar(bool defaultValue = false) const;
     void setShowStatusBar(const bool value) const;
 
     bool hideMenuFullscreen(bool defaultValue = false) const;
     void setHideMenuFullscreen(const bool value) const;
 
     bool hideScrollbarsFullscreen(bool defaultValue = false) const;
     void setHideScrollbarsFullscreen(const bool value) const;
 
     bool hideStatusbarFullscreen(bool defaultValue = false) const;
     void setHideStatusbarFullscreen(const bool value) const;
 
     bool hideTitlebarFullscreen(bool defaultValue = false) const;
     void setHideTitlebarFullscreen(const bool value) const;
 
     bool hideToolbarFullscreen(bool defaultValue = false) const;
     void setHideToolbarFullscreen(const bool value) const;
 
     bool fullscreenMode(bool defaultValue = false) const;
     void setFullscreenMode(const bool value) const;
 
     QStringList favoriteCompositeOps(bool defaultValue = false) const;
     void setFavoriteCompositeOps(const QStringList& compositeOps) const;
 
     QString exportConfigurationXML(const QString &filterId, bool defaultValue = false) const;
     KisPropertiesConfigurationSP exportConfiguration(const QString &filterId, bool defaultValue = false) const;
     void setExportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const;
 
     QString importConfiguration(const QString &filterId, bool defaultValue = false) const;
     void setImportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const;
 
     bool useOcio(bool defaultValue = false) const;
     void setUseOcio(bool useOCIO) const;
 
     int favoritePresets(bool defaultValue = false) const;
     void setFavoritePresets(const int value);
 
     bool levelOfDetailEnabled(bool defaultValue = false) const;
     void setLevelOfDetailEnabled(bool value);
 
     KisOcioConfiguration ocioConfiguration(bool defaultValue = false) const;
     void setOcioConfiguration(const KisOcioConfiguration &cfg);
 
     enum OcioColorManagementMode {
         INTERNAL = 0,
         OCIO_CONFIG,
         OCIO_ENVIRONMENT
     };
 
     OcioColorManagementMode ocioColorManagementMode(bool defaultValue = false) const;
     void setOcioColorManagementMode(OcioColorManagementMode mode) const;
 
     int ocioLutEdgeSize(bool defaultValue = false) const;
     void setOcioLutEdgeSize(int value);
 
     bool ocioLockColorVisualRepresentation(bool defaultValue = false) const;
     void setOcioLockColorVisualRepresentation(bool value);
 
     bool useSystemMonitorProfile(bool defaultValue = false) const;
     void setUseSystemMonitorProfile(bool _useSystemMonitorProfile) const;
 
     QString defaultPalette(bool defaultValue = false) const;
     void setDefaultPalette(const QString& name) const;
 
     QString toolbarSlider(int sliderNumber, bool defaultValue = false) const;
     void setToolbarSlider(int sliderNumber, const QString &slider);
 
 
     int layerThumbnailSize(bool defaultValue = false) const;
     void setLayerThumbnailSize(int size);
 
 
     bool sliderLabels(bool defaultValue = false) const;
     void setSliderLabels(bool enabled);
 
     QString currentInputProfile(bool defaultValue = false) const;
     void setCurrentInputProfile(const QString& name);
 
     bool presetStripVisible(bool defaultValue = false) const;
     void setPresetStripVisible(bool visible);
 
     bool scratchpadVisible(bool defaultValue = false) const;
     void setScratchpadVisible(bool visible);
 
     bool showSingleChannelAsColor(bool defaultValue = false) const;
     void setShowSingleChannelAsColor(bool asColor);
 
     bool hidePopups(bool defaultValue = false) const;
     void setHidePopups(bool hidepopups);
 
     int numDefaultLayers(bool defaultValue = false) const;
     void setNumDefaultLayers(int num);
 
     quint8 defaultBackgroundOpacity(bool defaultValue = false) const;
     void setDefaultBackgroundOpacity(quint8 value);
 
     QColor defaultBackgroundColor(bool defaultValue = false) const;
     void setDefaultBackgroundColor(QColor value);
 
     enum BackgroundStyle {
         RASTER_LAYER = 0,
         CANVAS_COLOR = 1,
         FILL_LAYER = 2
     };
 
     BackgroundStyle defaultBackgroundStyle(bool defaultValue = false) const;
     void setDefaultBackgroundStyle(BackgroundStyle value);
 
     int lineSmoothingType(bool defaultValue = false) const;
     void setLineSmoothingType(int value);
 
     qreal lineSmoothingDistance(bool defaultValue = false) const;
     void setLineSmoothingDistance(qreal value);
 
     qreal lineSmoothingTailAggressiveness(bool defaultValue = false) const;
     void setLineSmoothingTailAggressiveness(qreal value);
 
     bool lineSmoothingSmoothPressure(bool defaultValue = false) const;
     void setLineSmoothingSmoothPressure(bool value);
 
     bool lineSmoothingScalableDistance(bool defaultValue = false) const;
     void setLineSmoothingScalableDistance(bool value);
 
     qreal lineSmoothingDelayDistance(bool defaultValue = false) const;
     void setLineSmoothingDelayDistance(qreal value);
 
     bool lineSmoothingUseDelayDistance(bool defaultValue = false) const;
     void setLineSmoothingUseDelayDistance(bool value);
 
     bool lineSmoothingFinishStabilizedCurve(bool defaultValue = false) const;
     void setLineSmoothingFinishStabilizedCurve(bool value);
 
     bool lineSmoothingStabilizeSensors(bool defaultValue = false) const;
     void setLineSmoothingStabilizeSensors(bool value);
 
     int tabletEventsDelay(bool defaultValue = false) const;
     void setTabletEventsDelay(int value);
 
     bool trackTabletEventLatency(bool defaultValue = false) const;
     void setTrackTabletEventLatency(bool value);
 
     bool testingAcceptCompressedTabletEvents(bool defaultValue = false) const;
     void setTestingAcceptCompressedTabletEvents(bool value);
 
     bool shouldEatDriverShortcuts(bool defaultValue = false) const;
 
     bool testingCompressBrushEvents(bool defaultValue = false) const;
     void setTestingCompressBrushEvents(bool value);
 
     const KoColorSpace* customColorSelectorColorSpace(bool defaultValue = false) const;
     void setCustomColorSelectorColorSpace(const KoColorSpace *cs);
 
     bool useDirtyPresets(bool defaultValue = false) const;
     void setUseDirtyPresets(bool value);
 
     bool useEraserBrushSize(bool defaultValue = false) const;
     void setUseEraserBrushSize(bool value);
 
     bool useEraserBrushOpacity(bool defaultValue = false) const;
     void setUseEraserBrushOpacity(bool value);
 
     QString getMDIBackgroundColor(bool defaultValue = false) const;
     void setMDIBackgroundColor(const QString & v) const;
 
     QString getMDIBackgroundImage(bool defaultValue = false) const;
     void setMDIBackgroundImage(const QString & fileName) const;
 
     int workaroundX11SmoothPressureSteps(bool defaultValue = false) const;
 
     bool showCanvasMessages(bool defaultValue = false) const;
     void setShowCanvasMessages(bool show);
 
     bool compressKra(bool defaultValue = false) const;
     void setCompressKra(bool compress);
 
     bool toolOptionsInDocker(bool defaultValue = false) const;
     void setToolOptionsInDocker(bool inDocker);
 
     bool kineticScrollingEnabled(bool defaultValue = false) const;
     void setKineticScrollingEnabled(bool enabled);
 
     int kineticScrollingGesture(bool defaultValue = false) const;
     void setKineticScrollingGesture(int kineticScroll);
 
     int kineticScrollingSensitivity(bool defaultValue = false) const;
     void setKineticScrollingSensitivity(int sensitivity);
 
     bool kineticScrollingHiddenScrollbars(bool defaultValue = false) const;
     void setKineticScrollingHideScrollbars(bool scrollbar);
 
     void setEnableOpenGLFramerateLogging(bool value) const;
     bool enableOpenGLFramerateLogging(bool defaultValue = false) const;
 
     void setEnableBrushSpeedLogging(bool value) const;
     bool enableBrushSpeedLogging(bool defaultValue = false) const;
 
     void setEnableAmdVectorizationWorkaround(bool value);
     bool enableAmdVectorizationWorkaround(bool defaultValue = false) const;
 
     void setDisableAVXOptimizations(bool value);
     bool disableAVXOptimizations(bool defaultValue = false) const;
 
     bool animationDropFrames(bool defaultValue = false) const;
     void setAnimationDropFrames(bool value);
 
     int scrubbingUpdatesDelay(bool defaultValue = false) const;
     void setScrubbingUpdatesDelay(int value);
 
     int scrubbingAudioUpdatesDelay(bool defaultValue = false) const;
     void setScrubbingAudioUpdatesDelay(int value);
 
     int audioOffsetTolerance(bool defaultValue = false) const;
     void setAudioOffsetTolerance(int value);
 
     bool switchSelectionCtrlAlt(bool defaultValue = false) const;
     void setSwitchSelectionCtrlAlt(bool value);
 
     bool convertToImageColorspaceOnImport(bool defaultValue = false) const;
     void setConvertToImageColorspaceOnImport(bool value);
 
     int stabilizerSampleSize(bool defaultValue = false) const;
     void setStabilizerSampleSize(int value);
 
     bool stabilizerDelayedPaint(bool defaultValue = false) const;
     void setStabilizerDelayedPaint(bool value);
 
     bool showBrushHud(bool defaultValue = false) const;
     void setShowBrushHud(bool value);
 
     QString brushHudSetting(bool defaultValue = false) const;
     void setBrushHudSetting(const QString &value) const;
 
     bool calculateAnimationCacheInBackground(bool defaultValue = false) const;
     void setCalculateAnimationCacheInBackground(bool value);
 
     QColor defaultAssistantsColor(bool defaultValue = false) const;
     void setDefaultAssistantsColor(const QColor &color) const;
 
     bool autoSmoothBezierCurves(bool defaultValue = false) const;
     void setAutoSmoothBezierCurves(bool value);
     
     bool activateTransformToolAfterPaste(bool defaultValue = false) const;
     void setActivateTransformToolAfterPaste(bool value);
     
     enum RootSurfaceFormat {
         BT709_G22 = 0,
         BT709_G10,
         BT2020_PQ
     };
     RootSurfaceFormat rootSurfaceFormat(bool defaultValue = false) const;
     void setRootSurfaceFormat(RootSurfaceFormat value);
 
     static RootSurfaceFormat rootSurfaceFormat(QSettings *displayrc, bool defaultValue = false);
     static void setRootSurfaceFormat(QSettings *displayrc, RootSurfaceFormat value);
 
     bool useZip64(bool defaultValue = false) const;
     void setUseZip64(bool value);
 
     template<class T>
     void writeEntry(const QString& name, const T& value) {
         m_cfg.writeEntry(name, value);
     }
 
     template<class T>
     void writeList(const QString& name, const QList<T>& value) {
         m_cfg.writeEntry(name, value);
     }
 
     template<class T>
     T readEntry(const QString& name, const T& defaultValue=T()) {
         return m_cfg.readEntry(name, defaultValue);
     }
 
     template<class T>
     QList<T> readList(const QString& name, const QList<T>& defaultValue=QList<T>()) {
         return m_cfg.readEntry(name, defaultValue);
     }
 
 
     /// get the profile the color management system has stored for the given screen
     static const KoColorProfile* getScreenProfile(int screen);
 
 private:
     KisConfig(const KisConfig&);
     KisConfig& operator=(const KisConfig&) const;
 
 
 private:
     mutable KConfigGroup m_cfg;
     bool m_readOnly;
 };
 
 #endif // KIS_CONFIG_H_
diff --git a/libs/ui/opengl/kis_opengl.cpp b/libs/ui/opengl/kis_opengl.cpp
index 6231971c3b..6aa26c51ad 100644
--- a/libs/ui/opengl/kis_opengl.cpp
+++ b/libs/ui/opengl/kis_opengl.cpp
@@ -1,904 +1,912 @@
 /*
  *  Copyright (c) 2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <config-hdr.h>
 #include "opengl/kis_opengl.h"
 #include "opengl/kis_opengl_p.h"
 
 #include <QOpenGLContext>
 #include <QOpenGLDebugLogger>
 #include <QOpenGLFunctions>
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QPixmapCache>
 
 #include <QDir>
 #include <QFile>
 #include <QStandardPaths>
 #include <QVector>
 #include <QWindow>
 
 #include <klocalizedstring.h>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 #include "KisOpenGLModeProber.h"
 
 #include <KisUsageLogger.h>
 #include <boost/optional.hpp>
 #include "kis_assert.h"
 #include <QRegularExpression>
 #include <QSettings>
 
 #ifndef GL_RENDERER
 #  define GL_RENDERER 0x1F01
 #endif
 
 using namespace KisOpenGLPrivate;
 
 namespace
 {
     // config option, set manually by main()
     bool g_isDebugSynchronous = false;
 
     bool g_sanityDefaultFormatIsSet = false;
 
     boost::optional<KisOpenGLModeProber::Result> openGLCheckResult;
 
     bool g_needsFenceWorkaround = false;
     bool g_needsPixmapCacheWorkaround = false;
 
     QString g_surfaceFormatDetectionLog;
     QString g_debugText("OpenGL Info\n  **OpenGL not initialized**");
 
     QVector<KLocalizedString> g_openglWarningStrings;
     KisOpenGL::OpenGLRenderers g_supportedRenderers;
     KisOpenGL::OpenGLRenderer g_rendererPreferredByQt;
 
     void overrideSupportedRenderers(KisOpenGL::OpenGLRenderers supportedRenderers, KisOpenGL::OpenGLRenderer preferredByQt) {
         g_supportedRenderers = supportedRenderers;
         g_rendererPreferredByQt = preferredByQt;
     }
 
     void openglOnMessageLogged(const QOpenGLDebugMessage& debugMessage) {
         qDebug() << "OpenGL:" << debugMessage;
     }
 
     KisOpenGL::OpenGLRenderer getRendererFromProbeResult(KisOpenGLModeProber::Result info) {
 
         KisOpenGL::OpenGLRenderer result = KisOpenGL::RendererDesktopGL;
 
         if (info.isOpenGLES()) {
             const QString rendererString = info.rendererString().toLower();
 
             if (rendererString.contains("basic render driver") ||
                 rendererString.contains("software")) {
 
                 result = KisOpenGL::RendererSoftware;
             } else {
                 result = KisOpenGL::RendererOpenGLES;
             }
         }
 
         return result;
     }
 }
 
 KisOpenGLPrivate::OpenGLCheckResult::OpenGLCheckResult(QOpenGLContext &context) {
     if (!context.isValid()) {
         return;
     }
 
     QOpenGLFunctions *funcs = context.functions(); // funcs is ready to be used
 
     m_rendererString = QString(reinterpret_cast<const char *>(funcs->glGetString(GL_RENDERER)));
     m_driverVersionString = QString(reinterpret_cast<const char *>(funcs->glGetString(GL_VERSION)));
     m_glMajorVersion = context.format().majorVersion();
     m_glMinorVersion = context.format().minorVersion();
     m_supportsDeprecatedFunctions = (context.format().options() & QSurfaceFormat::DeprecatedFunctions);
     m_isOpenGLES = context.isOpenGLES();
 }
 
 void KisOpenGLPrivate::appendOpenGLWarningString(KLocalizedString warning)
 {
     g_openglWarningStrings << warning;
 }
 
 void KisOpenGLPrivate::overrideOpenGLWarningString(QVector<KLocalizedString> warnings)
 {
     g_openglWarningStrings = warnings;
 }
 
 
 void KisOpenGL::initialize()
 {
     if (openGLCheckResult) return;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(g_sanityDefaultFormatIsSet);
 
     KisOpenGL::RendererConfig config;
     config.format = QSurfaceFormat::defaultFormat();
 
     openGLCheckResult =
         KisOpenGLModeProber::instance()->probeFormat(config, false);
 
     g_debugText.clear();
     QDebug debugOut(&g_debugText);
     debugOut << "OpenGL Info\n";
 
     if (openGLCheckResult) {
         debugOut << "\n  Vendor: " << openGLCheckResult->vendorString();
         debugOut << "\n  Renderer: " << openGLCheckResult->rendererString();
         debugOut << "\n  Version: " << openGLCheckResult->driverVersionString();
         debugOut << "\n  Shading language: " << openGLCheckResult->shadingLanguageString();
         debugOut << "\n  Requested format: " << QSurfaceFormat::defaultFormat();
         debugOut << "\n  Current format:   " << openGLCheckResult->format();
         debugOut.nospace();
         debugOut << "\n     Version: " << openGLCheckResult->glMajorVersion() << "." << openGLCheckResult->glMinorVersion();
         debugOut.resetFormat();
         debugOut << "\n     Supports deprecated functions" << openGLCheckResult->supportsDeprecatedFunctions();
         debugOut << "\n     is OpenGL ES:" << openGLCheckResult->isOpenGLES();
     }
 
     debugOut << "\n\nQPA OpenGL Detection Info";
     debugOut << "\n  supportsDesktopGL:" << bool(g_supportedRenderers & RendererDesktopGL);
 #ifdef Q_OS_WIN
     debugOut << "\n  supportsAngleD3D11:" << bool(g_supportedRenderers & RendererOpenGLES);
     debugOut << "\n  isQtPreferAngle:" << bool(g_rendererPreferredByQt == RendererOpenGLES);
 #else
     debugOut << "\n  supportsOpenGLES:" << bool(g_supportedRenderers & RendererOpenGLES);
     debugOut << "\n  isQtPreferOpenGLES:" << bool(g_rendererPreferredByQt == RendererOpenGLES);
 #endif
     debugOut << "\n== log ==\n";
     debugOut.noquote();
     debugOut << g_surfaceFormatDetectionLog;
     debugOut.resetFormat();
     debugOut << "\n== end log ==";
 
     dbgOpenGL.noquote().nospace() << g_debugText;
     KisUsageLogger::write(g_debugText);
 
     if (!openGLCheckResult) {
         return;
     }
 
 
     // Check if we have a bugged driver that needs fence workaround
     bool isOnX11 = false;
 #ifdef HAVE_X11
     isOnX11 = true;
 #endif
 
     KisConfig cfg(true);
     if ((isOnX11 && openGLCheckResult->rendererString().startsWith("AMD")) || cfg.forceOpenGLFenceWorkaround()) {
         g_needsFenceWorkaround = true;
     }
 
     /**
      * NVidia + Qt's openGL don't play well together and one cannot
      * draw a pixmap on a widget more than once in one rendering cycle.
      *
      * It can be workarounded by drawing strictly via QPixmapCache and
      * only when the pixmap size in bigger than doubled size of the
      * display framebuffer. That is for 8-bit HD display, you should have
      * a cache bigger than 16 MiB. Don't ask me why. (DK)
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=361709
      *
      * TODO: check if this workaround is still needed after merging
      *       Qt5+openGL3 branch.
      */
 
     if (openGLCheckResult->vendorString().toUpper().contains("NVIDIA")) {
         g_needsPixmapCacheWorkaround = true;
 
         const QRect screenSize = QApplication::desktop()->screenGeometry();
         const int minCacheSize = 20 * 1024;
         const int cacheSize = 2048 + 2 * 4 * screenSize.width() * screenSize.height() / 1024; //KiB
 
         QPixmapCache::setCacheLimit(qMax(minCacheSize, cacheSize));
     }
 
 }
 
 void KisOpenGL::initializeContext(QOpenGLContext *ctx)
 {
     KisConfig cfg(true);
     initialize();
 
     const bool isDebugEnabled = ctx->format().testOption(QSurfaceFormat::DebugContext);
 
     dbgUI << "OpenGL: Opening new context";
     if (isDebugEnabled) {
         // Passing ctx for ownership management only, not specifying context.
         // QOpenGLDebugLogger only function on the current active context.
         // FIXME: Do we need to make sure ctx is the active context?
         QOpenGLDebugLogger* openglLogger = new QOpenGLDebugLogger(ctx);
         if (openglLogger->initialize()) {
             qDebug() << "QOpenGLDebugLogger is initialized. Check whether you get a message below.";
             QObject::connect(openglLogger, &QOpenGLDebugLogger::messageLogged, &openglOnMessageLogged);
             openglLogger->startLogging(g_isDebugSynchronous ? QOpenGLDebugLogger::SynchronousLogging : QOpenGLDebugLogger::AsynchronousLogging);
             openglLogger->logMessage(QOpenGLDebugMessage::createApplicationMessage(QStringLiteral("QOpenGLDebugLogger is logging.")));
         } else {
             qDebug() << "QOpenGLDebugLogger cannot be initialized.";
             delete openglLogger;
         }
     }
 
     // Double check we were given the version we requested
     QSurfaceFormat format = ctx->format();
     QOpenGLFunctions *f = ctx->functions();
     f->initializeOpenGLFunctions();
 
     QFile log(QStandardPaths::writableLocation(QStandardPaths::TempLocation) + "/krita-opengl.txt");
     log.open(QFile::WriteOnly);
     QString vendor((const char*)f->glGetString(GL_VENDOR));
     log.write(vendor.toLatin1());
     log.write(", ");
     log.write(openGLCheckResult->rendererString().toLatin1());
     log.write(", ");
     QString version((const char*)f->glGetString(GL_VERSION));
     log.write(version.toLatin1());
     log.close();
 }
 
 const QString &KisOpenGL::getDebugText()
 {
     initialize();
     return g_debugText;
 }
 
 QStringList KisOpenGL::getOpenGLWarnings() {
     QStringList strings;
     Q_FOREACH (const KLocalizedString &item, g_openglWarningStrings) {
         strings << item.toString();
     }
     return strings;
 }
 
 // XXX Temporary function to allow LoD on OpenGL3 without triggering
 // all of the other 3.2 functionality, can be removed once we move to Qt5.7
 bool KisOpenGL::supportsLoD()
 {
     initialize();
     return openGLCheckResult && openGLCheckResult->supportsLoD();
 }
 
 bool KisOpenGL::hasOpenGL3()
 {
     initialize();
     return openGLCheckResult && openGLCheckResult->hasOpenGL3();
 }
 
 bool KisOpenGL::hasOpenGLES()
 {
     initialize();
     return openGLCheckResult && openGLCheckResult->isOpenGLES();
 }
 
 bool KisOpenGL::supportsFenceSync()
 {
     initialize();
     return openGLCheckResult && openGLCheckResult->supportsFenceSync();
 }
 
 bool KisOpenGL::needsFenceWorkaround()
 {
     initialize();
     return g_needsFenceWorkaround;
 }
 
 bool KisOpenGL::needsPixmapCacheWorkaround()
 {
     initialize();
     return g_needsPixmapCacheWorkaround;
 }
 
 void KisOpenGL::testingInitializeDefaultSurfaceFormat()
 {
     setDefaultSurfaceConfig(selectSurfaceConfig(KisOpenGL::RendererAuto, KisConfig::BT709_G22, false));
 }
 
 void KisOpenGL::setDebugSynchronous(bool value)
 {
     g_isDebugSynchronous = value;
 }
 
 KisOpenGL::OpenGLRenderer KisOpenGL::getCurrentOpenGLRenderer()
 {
     if (!openGLCheckResult) return RendererAuto;
     return getRendererFromProbeResult(*openGLCheckResult);
 }
 
 KisOpenGL::OpenGLRenderer KisOpenGL::getQtPreferredOpenGLRenderer()
 {
     return g_rendererPreferredByQt;
 }
 
 KisOpenGL::OpenGLRenderers KisOpenGL::getSupportedOpenGLRenderers()
 {
     return g_supportedRenderers;
 }
 
 KisOpenGL::OpenGLRenderer KisOpenGL::getUserPreferredOpenGLRendererConfig()
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     return convertConfigToOpenGLRenderer(kritarc.value("OpenGLRenderer", "auto").toString());
 }
 
 void KisOpenGL::setUserPreferredOpenGLRendererConfig(KisOpenGL::OpenGLRenderer renderer)
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     kritarc.setValue("OpenGLRenderer", KisOpenGL::convertOpenGLRendererToConfig(renderer));
 }
 
 QString KisOpenGL::convertOpenGLRendererToConfig(KisOpenGL::OpenGLRenderer renderer)
 {
     switch (renderer) {
+    case RendererNone:
+        return QStringLiteral("none");
     case RendererSoftware:
         return QStringLiteral("software");
     case RendererDesktopGL:
         return QStringLiteral("desktop");
     case RendererOpenGLES:
         return QStringLiteral("angle");
     default:
         return QStringLiteral("auto");
     }
 }
 
 KisOpenGL::OpenGLRenderer KisOpenGL::convertConfigToOpenGLRenderer(QString renderer)
 {
     if (renderer == "desktop") {
         return RendererDesktopGL;
     } else if (renderer == "angle") {
         return RendererOpenGLES;
     } else if (renderer == "software") {
         return RendererSoftware;
+    } else if (renderer == "none") {
+        return RendererNone;
     } else {
         return RendererAuto;
     }
 }
 
 KisOpenGL::OpenGLRenderer KisOpenGL::RendererConfig::rendererId() const
 {
     KisOpenGL::OpenGLRenderer result = RendererAuto;
 
     if (format.renderableType() == QSurfaceFormat::OpenGLES &&
         angleRenderer == AngleRendererD3d11Warp) {
 
         result = RendererSoftware;
 
     } else if (format.renderableType() == QSurfaceFormat::OpenGLES &&
                angleRenderer == AngleRendererD3d11) {
 
         result = RendererOpenGLES;
     } else if (format.renderableType() == QSurfaceFormat::OpenGL) {
         result = RendererDesktopGL;
     } else if (format.renderableType() == QSurfaceFormat::DefaultRenderableType &&
                angleRenderer == AngleRendererD3d11) {
         // noop
     } else {
         qWarning() << "WARNING: unsupported combination of OpenGL renderer" << ppVar(format.renderableType()) << ppVar(angleRenderer);
     }
 
     return result;
 }
 
 namespace {
 
 typedef std::pair<QSurfaceFormat::RenderableType, KisOpenGL::AngleRenderer> RendererInfo;
 
 RendererInfo getRendererInfo(KisOpenGL::OpenGLRenderer renderer)
 {
     RendererInfo info = {QSurfaceFormat::DefaultRenderableType,
                          KisOpenGL::AngleRendererD3d11};
 
     switch (renderer) {
     case KisOpenGL::RendererNone:
+        info = {QSurfaceFormat::DefaultRenderableType, KisOpenGL::AngleRendererDefault};
+        break;
     case KisOpenGL::RendererAuto:
         break;
     case KisOpenGL::RendererDesktopGL:
         info = {QSurfaceFormat::OpenGL, KisOpenGL::AngleRendererD3d11};
         break;
     case KisOpenGL::RendererOpenGLES:
         info = {QSurfaceFormat::OpenGLES, KisOpenGL::AngleRendererD3d11};
         break;
     case KisOpenGL::RendererSoftware:
         info = {QSurfaceFormat::OpenGLES, KisOpenGL::AngleRendererD3d11Warp};
         break;
     }
 
     return info;
 }
 
 
 KisOpenGL::RendererConfig generateSurfaceConfig(KisOpenGL::OpenGLRenderer renderer,
                                                 KisConfig::RootSurfaceFormat rootSurfaceFormat,
                                                 bool debugContext)
 {
     RendererInfo info = getRendererInfo(renderer);
 
     KisOpenGL::RendererConfig config;
     config.angleRenderer = info.second;
 
     QSurfaceFormat &format = config.format;
 #ifdef Q_OS_MACOS
     format.setVersion(3, 2);
     format.setProfile(QSurfaceFormat::CoreProfile);
 #else
     // XXX This can be removed once we move to Qt5.7
     format.setVersion(3, 0);
     format.setProfile(QSurfaceFormat::CompatibilityProfile);
     format.setOptions(QSurfaceFormat::DeprecatedFunctions);
 #endif
     format.setDepthBufferSize(24);
     format.setStencilBufferSize(8);
 
     KisOpenGLModeProber::initSurfaceFormatFromConfig(rootSurfaceFormat, &format);
 
     format.setRenderableType(info.first);
     format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
     format.setSwapInterval(0); // Disable vertical refresh syncing
     if (debugContext) {
         format.setOption(QSurfaceFormat::DebugContext, true);
     }
 
     return config;
 }
 
 bool isOpenGLRendererBlacklisted(const QString &rendererString,
                                  const QString &driverVersionString,
                                  QVector<KLocalizedString> *warningMessage)
 {
     bool isBlacklisted = false;
 #ifndef Q_OS_WIN
     Q_UNUSED(rendererString);
     Q_UNUSED(driverVersionString);
     Q_UNUSED(warningMessage);
 #else
     // Special blacklisting of OpenGL/ANGLE is tracked on:
     // https://phabricator.kde.org/T7411
 
     // HACK: Specifically detect for Intel driver build number
     //       See https://www.intel.com/content/www/us/en/support/articles/000005654/graphics-drivers.html
     if (rendererString.startsWith("Intel")) {
         KLocalizedString knownBadIntelWarning = ki18n("The Intel graphics driver in use is known to have issues with OpenGL.");
         KLocalizedString grossIntelWarning = ki18n(
             "Intel graphics drivers tend to have issues with OpenGL so ANGLE will be used by default. "
             "You may manually switch to OpenGL but it is not guaranteed to work properly."
         );
         QRegularExpression regex("\\b\\d{1,2}\\.\\d{2}\\.\\d{1,3}\\.(\\d{4})\\b");
         QRegularExpressionMatch match = regex.match(driverVersionString);
         if (match.hasMatch()) {
             int driverBuild = match.captured(1).toInt();
             if (driverBuild > 4636 && driverBuild < 4729) {
                 // Make ANGLE the preferred renderer for Intel driver versions
                 // between build 4636 and 4729 (exclusive) due to an UI offset bug.
                 // See https://communities.intel.com/thread/116003
                 // (Build 4636 is known to work from some test results)
                 qDebug() << "Detected Intel driver build between 4636 and 4729, making ANGLE the preferred renderer";
                 isBlacklisted = true;
                 *warningMessage << knownBadIntelWarning;
             } else if (driverBuild == 4358) {
                 // There are several reports on a bug where the canvas is not being
                 // updated properly which has debug info pointing to this build.
                 qDebug() << "Detected Intel driver build 4358, making ANGLE the preferred renderer";
                 isBlacklisted = true;
                 *warningMessage << knownBadIntelWarning;
             } else {
                 // Intel tends to randomly break OpenGL in some of their new driver
                 // builds, therefore we just shouldn't use OpenGL by default to
                 // reduce bug report noises.
                 qDebug() << "Detected Intel driver, making ANGLE the preferred renderer";
                 isBlacklisted = true;
                 *warningMessage << grossIntelWarning;
             }
         } else {
             // In case Intel changed the driver version format to something that
             // we don't understand, we still select ANGLE.
             qDebug() << "Detected Intel driver with unknown version format, making ANGLE the preferred renderer";
             isBlacklisted = true;
             *warningMessage << grossIntelWarning;
         }
     }
 #endif
     return isBlacklisted;
 }
 
 boost::optional<bool> orderPreference(bool lhs, bool rhs)
 {
     if (lhs == rhs) return boost::none;
     if (lhs && !rhs) return true;
     if (!lhs && rhs) return false;
     return false;
 }
 
 #define ORDER_BY(lhs, rhs) if (auto res = orderPreference((lhs), (rhs))) { return *res; }
 
 class FormatPositionLess
 {
 public:
 
     FormatPositionLess()
     {
     }
 
     bool operator()(const KisOpenGL::RendererConfig &lhs, const KisOpenGL::RendererConfig &rhs) const {
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_preferredColorSpace != KisSurfaceColorSpace::DefaultColorSpace);
 
         if (m_preferredRendererByUser != KisOpenGL::RendererSoftware) {
             ORDER_BY(!isFallbackOnly(lhs.rendererId()), !isFallbackOnly(rhs.rendererId()));
         }
 
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         ORDER_BY(isPreferredColorSpace(lhs.format.colorSpace()),
                  isPreferredColorSpace(rhs.format.colorSpace()));
 #endif
 
         if (doPreferHDR()) {
             ORDER_BY(isHDRFormat(lhs.format), isHDRFormat(rhs.format));
         } else {
             ORDER_BY(!isHDRFormat(lhs.format), !isHDRFormat(rhs.format));
         }
 
         if (m_preferredRendererByUser != KisOpenGL::RendererAuto) {
             ORDER_BY(lhs.rendererId() == m_preferredRendererByUser,
                      rhs.rendererId() == m_preferredRendererByUser);
         }
 
         ORDER_BY(!isBlacklisted(lhs.rendererId()), !isBlacklisted(rhs.rendererId()));
 
         if (doPreferHDR() &&
             m_preferredRendererByHDR != KisOpenGL::RendererAuto) {
 
             ORDER_BY(lhs.rendererId() == m_preferredRendererByHDR,
                      rhs.rendererId() == m_preferredRendererByHDR);
 
         }
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_preferredRendererByQt != KisOpenGL::RendererAuto);
 
         ORDER_BY(lhs.rendererId() == m_preferredRendererByQt,
                  rhs.rendererId() == m_preferredRendererByQt);
 
         return false;
     }
 
 
 public:
     void setPreferredColorSpace(const KisSurfaceColorSpace &preferredColorSpace) {
         m_preferredColorSpace = preferredColorSpace;
     }
 
     void setPreferredRendererByQt(const KisOpenGL::OpenGLRenderer &preferredRendererByQt) {
         m_preferredRendererByQt = preferredRendererByQt;
     }
 
     void setPreferredRendererByUser(const KisOpenGL::OpenGLRenderer &preferredRendererByUser) {
         m_preferredRendererByUser = preferredRendererByUser;
     }
 
     void setPreferredRendererByHDR(const KisOpenGL::OpenGLRenderer &preferredRendererByHDR) {
         m_preferredRendererByHDR = preferredRendererByHDR;
     }
 
     void setOpenGLBlacklisted(bool openGLBlacklisted) {
         m_openGLBlacklisted = openGLBlacklisted;
     }
 
     void setOpenGLESBlacklisted(bool openGLESBlacklisted) {
         m_openGLESBlacklisted = openGLESBlacklisted;
     }
 
     bool isOpenGLBlacklisted() const {
         return m_openGLBlacklisted;
     }
 
     bool isOpenGLESBlacklisted() const {
         return m_openGLESBlacklisted;
     }
 
     KisSurfaceColorSpace preferredColorSpace() const {
         return m_preferredColorSpace;
     }
 
     KisOpenGL::OpenGLRenderer preferredRendererByUser() const {
         return m_preferredRendererByUser;
     }
 
 private:
     bool isHDRFormat(const QSurfaceFormat &f) const {
 #ifdef HAVE_HDR
         return f.colorSpace() == KisSurfaceColorSpace::bt2020PQColorSpace ||
             f.colorSpace() == KisSurfaceColorSpace::scRGBColorSpace;
 #else
         Q_UNUSED(f);
         return false;
 #endif
     }
 
     bool isFallbackOnly(KisOpenGL::OpenGLRenderer r) const {
         return r == KisOpenGL::RendererSoftware;
     }
 
     bool isBlacklisted(KisOpenGL::OpenGLRenderer r) const {
         KIS_SAFE_ASSERT_RECOVER_NOOP(r == KisOpenGL::RendererAuto ||
                                      r == KisOpenGL::RendererDesktopGL ||
                                      r == KisOpenGL::RendererOpenGLES ||
-                                     r == KisOpenGL::RendererSoftware);
+                                     r == KisOpenGL::RendererSoftware ||
+                                     r == KisOpenGL::RendererNone);
 
         return (r == KisOpenGL::RendererDesktopGL && m_openGLBlacklisted) ||
             (r == KisOpenGL::RendererOpenGLES && m_openGLESBlacklisted) ||
             (r == KisOpenGL::RendererSoftware && m_openGLESBlacklisted);
     }
 
     bool doPreferHDR() const {
 #ifdef HAVE_HDR
         return m_preferredColorSpace == KisSurfaceColorSpace::bt2020PQColorSpace ||
             m_preferredColorSpace == KisSurfaceColorSpace::scRGBColorSpace;
 #else
         return false;
 #endif
     }
 
     bool isPreferredColorSpace(const KisSurfaceColorSpace cs) const {
         return KisOpenGLModeProber::fuzzyCompareColorSpaces(m_preferredColorSpace, cs);
         return false;
     }
 
 private:
     KisSurfaceColorSpace m_preferredColorSpace = KisSurfaceColorSpace::DefaultColorSpace;
     KisOpenGL::OpenGLRenderer m_preferredRendererByQt = KisOpenGL::RendererDesktopGL;
     KisOpenGL::OpenGLRenderer m_preferredRendererByUser = KisOpenGL::RendererAuto;
     KisOpenGL::OpenGLRenderer m_preferredRendererByHDR = KisOpenGL::RendererAuto;
     bool m_openGLBlacklisted = false;
     bool m_openGLESBlacklisted = false;
 };
 
 struct DetectionDebug : public QDebug
 {
     DetectionDebug(QString *string)
         : QDebug(string),
           m_string(string),
           m_originalSize(string->size())
     {}
     ~DetectionDebug() { dbgOpenGL << m_string->right(m_string->size() - m_originalSize); *this << endl; }
 
     QString *m_string;
     int m_originalSize;
 };
 }
 
 #define dbgDetection() DetectionDebug(&g_surfaceFormatDetectionLog)
 
 KisOpenGL::RendererConfig KisOpenGL::selectSurfaceConfig(KisOpenGL::OpenGLRenderer preferredRenderer,
                                                          KisConfig::RootSurfaceFormat preferredRootSurfaceFormat,
                                                          bool enableDebug)
 {
     QVector<KLocalizedString> warningMessages;
 
     using Info = boost::optional<KisOpenGLModeProber::Result>;
 
     QHash<OpenGLRenderer, Info> renderersToTest;
     renderersToTest.insert(RendererDesktopGL, Info());
     renderersToTest.insert(RendererOpenGLES, Info());
 
 #ifdef Q_OS_WIN
     renderersToTest.insert(RendererSoftware, Info());
 #endif
 
 
 #ifdef HAVE_HDR
     QVector<KisConfig::RootSurfaceFormat> formatSymbols({KisConfig::BT709_G22, KisConfig::BT709_G10, KisConfig::BT2020_PQ});
 #else
     QVector<KisConfig::RootSurfaceFormat> formatSymbols({KisConfig::BT709_G22});
 #endif
 
     KisOpenGL::RendererConfig defaultConfig = generateSurfaceConfig(KisOpenGL::RendererAuto,
                                                                     KisConfig::BT709_G22, false);
     Info info = KisOpenGLModeProber::instance()->probeFormat(defaultConfig);
 
 #ifdef Q_OS_WIN
     if (!info) {
-        renderersToTest.remove(RendererDesktopGL);
-        renderersToTest.remove(RendererOpenGLES);
-
         // try software rasterizer (WARP)
         defaultConfig = generateSurfaceConfig(KisOpenGL::RendererSoftware,
                                               KisConfig::BT709_G22, false);
         info = KisOpenGLModeProber::instance()->probeFormat(defaultConfig);
 
         if (!info) {
             renderersToTest.remove(RendererSoftware);
         }
     }
 #endif
 
     if (!info) return KisOpenGL::RendererConfig();
 
     const OpenGLRenderer defaultRenderer = getRendererFromProbeResult(*info);
 
     OpenGLRenderers supportedRenderers = RendererNone;
-    supportedRenderers |= defaultRenderer;
 
     FormatPositionLess compareOp;
     compareOp.setPreferredRendererByQt(defaultRenderer);
 
 #ifdef HAVE_HDR
     compareOp.setPreferredColorSpace(
         preferredRootSurfaceFormat == KisConfig::BT709_G22 ? KisSurfaceColorSpace::sRGBColorSpace :
         preferredRootSurfaceFormat == KisConfig::BT709_G10 ? KisSurfaceColorSpace::scRGBColorSpace :
         KisSurfaceColorSpace::bt2020PQColorSpace);
 #else
     Q_UNUSED(preferredRootSurfaceFormat);
     compareOp.setPreferredColorSpace(KisSurfaceColorSpace::sRGBColorSpace);
 #endif
 
 #ifdef Q_OS_WIN
     compareOp.setPreferredRendererByHDR(KisOpenGL::RendererOpenGLES);
 #endif
     compareOp.setPreferredRendererByUser(preferredRenderer);
     compareOp.setOpenGLESBlacklisted(false); // We cannot blacklist ES drivers atm
 
 
     renderersToTest[defaultRenderer] = info;
 
     for (auto it = renderersToTest.begin(); it != renderersToTest.end(); ++it) {
         Info info = it.value();
 
         if (!info) {
             info = KisOpenGLModeProber::instance()->
                     probeFormat(generateSurfaceConfig(it.key(),
                                                       KisConfig::BT709_G22, false));
             *it = info;
         }
 
         compareOp.setOpenGLBlacklisted(
             !info ||
             isOpenGLRendererBlacklisted(info->rendererString(),
                                         info->driverVersionString(),
                                         &warningMessages));
 
         if (info && info->isSupportedVersion()) {
             supportedRenderers |= it.key();
         }
     }
 
     OpenGLRenderer preferredByQt = defaultRenderer;
 
     if (preferredByQt == RendererDesktopGL &&
         supportedRenderers & RendererDesktopGL &&
         compareOp.isOpenGLBlacklisted()) {
 
         preferredByQt = RendererOpenGLES;
 
     } else if (preferredByQt == RendererOpenGLES &&
                supportedRenderers & RendererOpenGLES &&
                compareOp.isOpenGLESBlacklisted()) {
 
         preferredByQt = RendererDesktopGL;
     }
 
     QVector<RendererConfig> preferredConfigs;
     for (auto it = renderersToTest.begin(); it != renderersToTest.end(); ++it) {
         // if default mode of the renderer doesn't work, then custom won't either
         if (!it.value()) continue;
 
         Q_FOREACH (const KisConfig::RootSurfaceFormat formatSymbol, formatSymbols) {
             preferredConfigs << generateSurfaceConfig(it.key(), formatSymbol, enableDebug);
         }
     }
 
     std::stable_sort(preferredConfigs.begin(), preferredConfigs.end(), compareOp);
 
     dbgDetection() << "Supported renderers:" << supportedRenderers;
 
     dbgDetection() << "Surface format preference list:";
     Q_FOREACH (const KisOpenGL::RendererConfig &config, preferredConfigs) {
         dbgDetection() << "*" << config.format;
         dbgDetection() << "   " << config.rendererId();
     }
 
     KisOpenGL::RendererConfig resultConfig = defaultConfig;
 
-    Q_FOREACH (const KisOpenGL::RendererConfig &config, preferredConfigs) {
+    if (preferredRenderer != RendererNone) {
+        Q_FOREACH (const KisOpenGL::RendererConfig &config, preferredConfigs) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
-        dbgDetection() <<"Probing format..." << config.format.colorSpace() << config.rendererId();
+            dbgDetection() <<"Probing format..." << config.format.colorSpace() << config.rendererId();
 #else
-        dbgDetection() <<"Probing format..." << config.rendererId();
+            dbgDetection() <<"Probing format..." << config.rendererId();
 #endif
-        Info info = KisOpenGLModeProber::instance()->probeFormat(config);
+            Info info = KisOpenGLModeProber::instance()->probeFormat(config);
 
-        if (info && info->isSupportedVersion()) {
+            if (info && info->isSupportedVersion()) {
 
 #ifdef Q_OS_WIN
-            // HACK: Block ANGLE with Direct3D9
-            //       Direct3D9 does not give OpenGL ES 3.0
-            //       Some versions of ANGLE returns OpenGL version 3.0 incorrectly
+                // HACK: Block ANGLE with Direct3D9
+                //       Direct3D9 does not give OpenGL ES 3.0
+                //       Some versions of ANGLE returns OpenGL version 3.0 incorrectly
 
-            if (info->isUsingAngle() &&
-                info->rendererString().contains("Direct3D9", Qt::CaseInsensitive)) {
+                if (info->isUsingAngle() &&
+                        info->rendererString().contains("Direct3D9", Qt::CaseInsensitive)) {
 
-                dbgDetection() << "Skipping Direct3D 9 Angle implementation, it shouldn't have happened.";
+                    dbgDetection() << "Skipping Direct3D 9 Angle implementation, it shouldn't have happened.";
 
-                continue;
-            }
+                    continue;
+                }
 #endif
 
-            dbgDetection() << "Found format:" << config.format;
-            dbgDetection() << "   " << config.rendererId();
+                dbgDetection() << "Found format:" << config.format;
+                dbgDetection() << "   " << config.rendererId();
 
-            resultConfig = config;
-            break;
+                resultConfig = config;
+                break;
+            }
         }
-    }
 
-    {
-        const bool colorSpaceIsCorrect =
-#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
-            KisOpenGLModeProber::fuzzyCompareColorSpaces(compareOp.preferredColorSpace(),
-                                                         resultConfig.format.colorSpace());
+        {
+            const bool colorSpaceIsCorrect =
+        #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
+                    KisOpenGLModeProber::fuzzyCompareColorSpaces(compareOp.preferredColorSpace(),
+                                                                 resultConfig.format.colorSpace());
 #else
-            true;
+                    true;
 #endif
 
-        const bool rendererIsCorrect =
-            compareOp.preferredRendererByUser() == KisOpenGL::RendererAuto ||
-            compareOp.preferredRendererByUser() == resultConfig.rendererId();
+            const bool rendererIsCorrect =
+                    compareOp.preferredRendererByUser() == KisOpenGL::RendererAuto ||
+                    compareOp.preferredRendererByUser() == resultConfig.rendererId();
 
-        if (!rendererIsCorrect && colorSpaceIsCorrect) {
-            warningMessages << ki18n("Preferred renderer doesn't support requested surface format. Another renderer has been selected.");
-        } else if (!colorSpaceIsCorrect) {
-            warningMessages << ki18n("Preferred output format is not supported by available renderers");
-        }
+            if (!rendererIsCorrect && colorSpaceIsCorrect) {
+                warningMessages << ki18n("Preferred renderer doesn't support requested surface format. Another renderer has been selected.");
+            } else if (!colorSpaceIsCorrect) {
+                warningMessages << ki18n("Preferred output format is not supported by available renderers");
+            }
 
+        }
+    } else {
+        resultConfig.format = QSurfaceFormat();
+        resultConfig.angleRenderer = AngleRendererDefault;
     }
 
     overrideSupportedRenderers(supportedRenderers, preferredByQt);
     overrideOpenGLWarningString(warningMessages);
 
     return resultConfig;
 }
 
 void KisOpenGL::setDefaultSurfaceConfig(const KisOpenGL::RendererConfig &config)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(!g_sanityDefaultFormatIsSet);
 
     g_sanityDefaultFormatIsSet = true;
     QSurfaceFormat::setDefaultFormat(config.format);
 
 #ifdef Q_OS_WIN
     // Force ANGLE to use Direct3D11. D3D9 doesn't support OpenGL ES 3 and WARP
     //  might get weird crashes atm.
     qputenv("QT_ANGLE_PLATFORM", KisOpenGLModeProber::angleRendererToString(config.angleRenderer).toLatin1());
 #endif
 
     if (config.format.renderableType() == QSurfaceFormat::OpenGLES) {
         QCoreApplication::setAttribute(Qt::AA_UseOpenGLES, true);
-    } else {
+    } else if (config.format.renderableType() == QSurfaceFormat::OpenGL) {
         QCoreApplication::setAttribute(Qt::AA_UseDesktopOpenGL, true);
     }
 }
 
 bool KisOpenGL::hasOpenGL()
 {
     return openGLCheckResult->isSupportedVersion();
 }
diff --git a/libs/ui/opengl/kis_opengl_canvas2.cpp b/libs/ui/opengl/kis_opengl_canvas2.cpp
index c34b4c53ce..9401b990bc 100644
--- a/libs/ui/opengl/kis_opengl_canvas2.cpp
+++ b/libs/ui/opengl/kis_opengl_canvas2.cpp
@@ -1,1035 +1,1035 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006-2013
  * Copyright (C) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #define GL_GLEXT_PROTOTYPES
 
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl_canvas2_p.h"
 
 #include "opengl/kis_opengl_shader_loader.h"
 #include "opengl/kis_opengl_canvas_debugger.h"
 #include "canvas/kis_canvas2.h"
 #include "canvas/kis_coordinates_converter.h"
 #include "canvas/kis_display_filter.h"
 #include "canvas/kis_display_color_converter.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_debug.h"
 
 #include <QPainter>
 #include <QPainterPath>
 #include <QPointF>
 #include <QMatrix>
 #include <QTransform>
 #include <QThread>
 #include <QFile>
 #include <QOpenGLShaderProgram>
 #include <QOpenGLVertexArrayObject>
 #include <QOpenGLBuffer>
 #include <QMessageBox>
 #include "KisOpenGLModeProber.h"
 #include <KoColorModelStandardIds.h>
 
 #ifndef Q_OS_MACOS
 #include <QOpenGLFunctions_2_1>
 #endif
 
 #define NEAR_VAL -1000.0
 #define FAR_VAL 1000.0
 
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
 
 #define PROGRAM_VERTEX_ATTRIBUTE 0
 #define PROGRAM_TEXCOORD_ATTRIBUTE 1
 
 static bool OPENGL_SUCCESS = false;
 
 struct KisOpenGLCanvas2::Private
 {
 public:
     ~Private() {
         delete displayShader;
         delete checkerShader;
         delete solidColorShader;
         Sync::deleteSync(glSyncObject);
     }
 
     bool canvasInitialized{false};
 
     KisOpenGLImageTexturesSP openGLImageTextures;
 
     KisOpenGLShaderLoader shaderLoader;
     KisShaderProgram *displayShader{0};
     KisShaderProgram *checkerShader{0};
     KisShaderProgram *solidColorShader{0};
     bool displayShaderCompiledWithDisplayFilterSupport{false};
 
     GLfloat checkSizeScale;
     bool scrollCheckers;
 
     QSharedPointer<KisDisplayFilter> displayFilter;
     KisOpenGL::FilterMode filterMode;
     bool proofingConfigIsUpdated=false;
 
     GLsync glSyncObject{0};
 
     bool wrapAroundMode{false};
 
     // Stores a quad for drawing the canvas
     QOpenGLVertexArrayObject quadVAO;
     QOpenGLBuffer quadBuffers[2];
 
     // Stores data for drawing tool outlines
     QOpenGLVertexArrayObject outlineVAO;
     QOpenGLBuffer lineBuffer;
 
     QVector3D vertices[6];
     QVector2D texCoords[6];
 
 #ifndef Q_OS_MACOS
     QOpenGLFunctions_2_1 *glFn201;
 #endif
 
     qreal pixelGridDrawingThreshold;
     bool pixelGridEnabled;
     QColor gridColor;
     QColor cursorColor;
 
     bool lodSwitchInProgress = false;
 
     int xToColWithWrapCompensation(int x, const QRect &imageRect) {
         int firstImageColumn = openGLImageTextures->xToCol(imageRect.left());
         int lastImageColumn = openGLImageTextures->xToCol(imageRect.right());
 
         int colsPerImage = lastImageColumn - firstImageColumn + 1;
         int numWraps = floor(qreal(x) / imageRect.width());
         int remainder = x - imageRect.width() * numWraps;
 
         return colsPerImage * numWraps + openGLImageTextures->xToCol(remainder);
     }
 
     int yToRowWithWrapCompensation(int y, const QRect &imageRect) {
         int firstImageRow = openGLImageTextures->yToRow(imageRect.top());
         int lastImageRow = openGLImageTextures->yToRow(imageRect.bottom());
 
         int rowsPerImage = lastImageRow - firstImageRow + 1;
         int numWraps = floor(qreal(y) / imageRect.height());
         int remainder = y - imageRect.height() * numWraps;
 
         return rowsPerImage * numWraps + openGLImageTextures->yToRow(remainder);
     }
 
 };
 
 KisOpenGLCanvas2::KisOpenGLCanvas2(KisCanvas2 *canvas,
                                    KisCoordinatesConverter *coordinatesConverter,
                                    QWidget *parent,
                                    KisImageWSP image,
                                    KisDisplayColorConverter *colorConverter)
     : QOpenGLWidget(parent)
     , KisCanvasWidgetBase(canvas, coordinatesConverter)
     , d(new Private())
 {
     KisConfig cfg(false);
     cfg.setCanvasState("OPENGL_STARTED");
 
     d->openGLImageTextures =
             KisOpenGLImageTextures::getImageTextures(image,
                                                      colorConverter->openGLCanvasSurfaceProfile(),
                                                      colorConverter->renderingIntent(),
                                                      colorConverter->conversionFlags());
 
     setAcceptDrops(true);
     setAutoFillBackground(false);
 
     setFocusPolicy(Qt::StrongFocus);
     setAttribute(Qt::WA_NoSystemBackground, true);
 #ifdef Q_OS_MACOS
     setAttribute(Qt::WA_AcceptTouchEvents, false);
 #else
     setAttribute(Qt::WA_AcceptTouchEvents, true);
 #endif
     setAttribute(Qt::WA_InputMethodEnabled, false);
     setAttribute(Qt::WA_DontCreateNativeAncestors, true);
 
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
     // we should make sure the texture doesn't have alpha channel,
     // otherwise blending will not work correctly.
     if (KisOpenGLModeProber::instance()->useHDRMode()) {
         setTextureFormat(GL_RGBA16F);
     } else {
         /**
          * When in pure OpenGL mode, the canvas surface will have alpha
          * channel. Therefore, if our canvas blending algorithm produces
          * semi-transparent pixels (and it does), then Krita window itself
          * will become transparent. Which is not good.
          *
          * In Angle mode, GL_RGB8 is not available (and the transparence effect
          * doesn't exist at all).
          */
         if (!KisOpenGL::hasOpenGLES()) {
             setTextureFormat(GL_RGB8);
         }
     }
 #endif
 
     setDisplayFilterImpl(colorConverter->displayFilter(), true);
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(KisConfigNotifier::instance(), SIGNAL(pixelGridModeChanged()), SLOT(slotPixelGridModeChanged()));
     slotConfigChanged();
     slotPixelGridModeChanged();
     cfg.writeEntry("canvasState", "OPENGL_SUCCESS");
 }
 
 KisOpenGLCanvas2::~KisOpenGLCanvas2()
 {
     delete d;
 }
 
 void KisOpenGLCanvas2::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     setDisplayFilterImpl(displayFilter, false);
 }
 
 void KisOpenGLCanvas2::setDisplayFilterImpl(QSharedPointer<KisDisplayFilter> displayFilter, bool initializing)
 {
     bool needsInternalColorManagement =
             !displayFilter || displayFilter->useInternalColorManagement();
 
     bool needsFullRefresh = d->openGLImageTextures->setInternalColorManagementActive(needsInternalColorManagement);
 
     d->displayFilter = displayFilter;
 
     if (!initializing && needsFullRefresh) {
         canvas()->startUpdateInPatches(canvas()->image()->bounds());
     }
     else if (!initializing)  {
         canvas()->updateCanvas();
     }
 }
 
 void KisOpenGLCanvas2::notifyImageColorSpaceChanged(const KoColorSpace *cs)
 {
     // FIXME: on color space change the data is refetched multiple
     //        times by different actors!
 
     if (d->openGLImageTextures->setImageColorSpace(cs)) {
         canvas()->startUpdateInPatches(canvas()->image()->bounds());
     }
 }
 
 void KisOpenGLCanvas2::setWrapAroundViewingMode(bool value)
 {
     d->wrapAroundMode = value;
     update();
 }
 
 inline void rectToVertices(QVector3D* vertices, const QRectF &rc)
 {
     vertices[0] = QVector3D(rc.left(),  rc.bottom(), 0.f);
     vertices[1] = QVector3D(rc.left(),  rc.top(),    0.f);
     vertices[2] = QVector3D(rc.right(), rc.bottom(), 0.f);
     vertices[3] = QVector3D(rc.left(),  rc.top(), 0.f);
     vertices[4] = QVector3D(rc.right(), rc.top(), 0.f);
     vertices[5] = QVector3D(rc.right(), rc.bottom(),    0.f);
 }
 
 inline void rectToTexCoords(QVector2D* texCoords, const QRectF &rc)
 {
     texCoords[0] = QVector2D(rc.left(), rc.bottom());
     texCoords[1] = QVector2D(rc.left(), rc.top());
     texCoords[2] = QVector2D(rc.right(), rc.bottom());
     texCoords[3] = QVector2D(rc.left(), rc.top());
     texCoords[4] = QVector2D(rc.right(), rc.top());
     texCoords[5] = QVector2D(rc.right(), rc.bottom());
 }
 
 void KisOpenGLCanvas2::initializeGL()
 {
     KisOpenGL::initializeContext(context());
     initializeOpenGLFunctions();
 #ifndef Q_OS_MACOS
     if (!KisOpenGL::hasOpenGLES()) {
         d->glFn201 = context()->versionFunctions<QOpenGLFunctions_2_1>();
         if (!d->glFn201) {
             warnUI << "Cannot obtain QOpenGLFunctions_2_1, glLogicOp cannot be used";
         }
     } else {
         d->glFn201 = nullptr;
     }
 #endif
 
     KisConfig cfg(true);
     d->openGLImageTextures->setProofingConfig(canvas()->proofingConfiguration());
     d->openGLImageTextures->initGL(context()->functions());
     d->openGLImageTextures->generateCheckerTexture(createCheckersImage(cfg.checkSize()));
 
     initializeShaders();
 
     // If we support OpenGL 3.2, then prepare our VAOs and VBOs for drawing
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.create();
         d->quadVAO.bind();
 
         glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE);
         glEnableVertexAttribArray(PROGRAM_TEXCOORD_ATTRIBUTE);
 
         // Create the vertex buffer object, it has 6 vertices with 3 components
         d->quadBuffers[0].create();
         d->quadBuffers[0].setUsagePattern(QOpenGLBuffer::StaticDraw);
         d->quadBuffers[0].bind();
         d->quadBuffers[0].allocate(d->vertices, 6 * 3 * sizeof(float));
         glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0);
 
         // Create the texture buffer object, it has 6 texture coordinates with 2 components
         d->quadBuffers[1].create();
         d->quadBuffers[1].setUsagePattern(QOpenGLBuffer::StaticDraw);
         d->quadBuffers[1].bind();
         d->quadBuffers[1].allocate(d->texCoords, 6 * 2 * sizeof(float));
         glVertexAttribPointer(PROGRAM_TEXCOORD_ATTRIBUTE, 2, GL_FLOAT, GL_FALSE, 0, 0);
 
         // Create the outline buffer, this buffer will store the outlines of
         // tools and will frequently change data
         d->outlineVAO.create();
         d->outlineVAO.bind();
 
         glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE);
 
         // The outline buffer has a StreamDraw usage pattern, because it changes constantly
         d->lineBuffer.create();
         d->lineBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw);
         d->lineBuffer.bind();
         glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0);
     }
 
     Sync::init(context());
 
     d->canvasInitialized = true;
 }
 
 /**
  * Loads all shaders and reports compilation problems
  */
 void KisOpenGLCanvas2::initializeShaders()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->canvasInitialized);
 
     delete d->checkerShader;
     delete d->solidColorShader;
     d->checkerShader = 0;
     d->solidColorShader = 0;
 
     try {
         d->checkerShader = d->shaderLoader.loadCheckerShader();
         d->solidColorShader = d->shaderLoader.loadSolidColorShader();
     } catch (const ShaderLoaderException &e) {
         reportFailedShaderCompilation(e.what());
     }
 
     initializeDisplayShader();
 }
 
 void KisOpenGLCanvas2::initializeDisplayShader()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->canvasInitialized);
 
     bool useHiQualityFiltering = d->filterMode == KisOpenGL::HighQualityFiltering;
 
     delete d->displayShader;
     d->displayShader = 0;
 
     try {
         d->displayShader = d->shaderLoader.loadDisplayShader(d->displayFilter, useHiQualityFiltering);
         d->displayShaderCompiledWithDisplayFilterSupport = d->displayFilter;
     } catch (const ShaderLoaderException &e) {
         reportFailedShaderCompilation(e.what());
     }
 }
 
 /**
  * Displays a message box telling the user that
  * shader compilation failed and turns off OpenGL.
  */
 void KisOpenGLCanvas2::reportFailedShaderCompilation(const QString &context)
 {
     KisConfig cfg(false);
 
     qDebug() << "Shader Compilation Failure: " << context;
     QMessageBox::critical(this, i18nc("@title:window", "Krita"),
                           i18n("Krita could not initialize the OpenGL canvas:\n\n%1\n\n Krita will disable OpenGL and close now.", context),
                           QMessageBox::Close);
 
-    cfg.setUseOpenGL(false);
+    cfg.disableOpenGL();
     cfg.setCanvasState("OPENGL_FAILED");
 }
 
 void KisOpenGLCanvas2::resizeGL(int /*width*/, int /*height*/)
 {
     // The given size is the widget size but here we actually want to give
     // KisCoordinatesConverter the viewport size aligned to device pixels.
     coordinatesConverter()->setCanvasWidgetSize(widgetSizeAlignedToDevicePixel());
     paintGL();
 }
 
 void KisOpenGLCanvas2::paintGL()
 {
     if (!OPENGL_SUCCESS) {
         KisConfig cfg(false);
         cfg.writeEntry("canvasState", "OPENGL_PAINT_STARTED");
     }
 
     KisOpenglCanvasDebugger::instance()->nofityPaintRequested();
 
     renderCanvasGL();
 
     if (d->glSyncObject) {
         Sync::deleteSync(d->glSyncObject);
     }
     d->glSyncObject = Sync::getSync();
 
     QPainter gc(this);
     renderDecorations(&gc);
     gc.end();
 
     if (!OPENGL_SUCCESS) {
         KisConfig cfg(false);
         cfg.writeEntry("canvasState", "OPENGL_SUCCESS");
         OPENGL_SUCCESS = true;
     }
 }
 
 void KisOpenGLCanvas2::paintToolOutline(const QPainterPath &path)
 {
     if (!d->solidColorShader->bind()) {
         return;
     }
 
     QSizeF widgetSize = widgetSizeAlignedToDevicePixel();
 
     // setup the mvp transformation
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     // FIXME: It may be better to have the projection in device pixel, but
     //       this requires introducing a new coordinate system.
     projectionMatrix.ortho(0, widgetSize.width(), widgetSize.height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(coordinatesConverter()->flakeToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->solidColorShader->setUniformValue(d->solidColorShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     if (!KisOpenGL::hasOpenGLES()) {
         glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
 
         glEnable(GL_COLOR_LOGIC_OP);
 #ifndef Q_OS_MACOS
         if (d->glFn201) {
             d->glFn201->glLogicOp(GL_XOR);
         }
 #else
         glLogicOp(GL_XOR);
 #endif
     } else {
         glEnable(GL_BLEND);
         glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR, GL_ZERO, GL_ONE, GL_ONE);
     }
 
     d->solidColorShader->setUniformValue(
                 d->solidColorShader->location(Uniform::FragmentColor),
                 QVector4D(d->cursorColor.redF(), d->cursorColor.greenF(), d->cursorColor.blueF(), 1.0f));
 
     // Paint the tool outline
     if (KisOpenGL::hasOpenGL3()) {
         d->outlineVAO.bind();
         d->lineBuffer.bind();
     }
 
     // Convert every disjointed subpath to a polygon and draw that polygon
     QList<QPolygonF> subPathPolygons = path.toSubpathPolygons();
     for (int i = 0; i < subPathPolygons.size(); i++) {
         const QPolygonF& polygon = subPathPolygons.at(i);
 
         QVector<QVector3D> vertices;
         vertices.resize(polygon.count());
 
         for (int j = 0; j < polygon.count(); j++) {
             QPointF p = polygon.at(j);
             vertices[j].setX(p.x());
             vertices[j].setY(p.y());
         }
         if (KisOpenGL::hasOpenGL3()) {
             d->lineBuffer.allocate(vertices.constData(), 3 * vertices.size() * sizeof(float));
         }
         else {
             d->solidColorShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
             d->solidColorShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, vertices.constData());
         }
 
         glDrawArrays(GL_LINE_STRIP, 0, vertices.size());
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.release();
         d->outlineVAO.release();
     }
 
     if (!KisOpenGL::hasOpenGLES()) {
         glDisable(GL_COLOR_LOGIC_OP);
     } else {
         glDisable(GL_BLEND);
     }
 
     d->solidColorShader->release();
 }
 
 bool KisOpenGLCanvas2::isBusy() const
 {
     const bool isBusyStatus = Sync::syncStatus(d->glSyncObject) == Sync::Unsignaled;
     KisOpenglCanvasDebugger::instance()->nofitySyncStatus(isBusyStatus);
 
     return isBusyStatus;
 }
 
 void KisOpenGLCanvas2::setLodResetInProgress(bool value)
 {
     d->lodSwitchInProgress = value;
 }
 
 void KisOpenGLCanvas2::drawCheckers()
 {
     if (!d->checkerShader) {
         return;
     }
 
     KisCoordinatesConverter *converter = coordinatesConverter();
     QTransform textureTransform;
     QTransform modelTransform;
     QRectF textureRect;
     QRectF modelRect;
 
     QSizeF widgetSize = widgetSizeAlignedToDevicePixel();
     QRectF viewportRect = !d->wrapAroundMode ?
                 converter->imageRectInViewportPixels() :
                 converter->widgetToViewport(QRectF(0, 0, widgetSize.width(), widgetSize.height()));
 
     if (!canvas()->renderingLimit().isEmpty()) {
         const QRect vrect = converter->imageToViewport(canvas()->renderingLimit()).toAlignedRect();
         viewportRect &= vrect;
     }
 
     converter->getOpenGLCheckersInfo(viewportRect,
                                      &textureTransform, &modelTransform, &textureRect, &modelRect, d->scrollCheckers);
 
     textureTransform *= QTransform::fromScale(d->checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE,
                                               d->checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE);
 
     if (!d->checkerShader->bind()) {
         qWarning() << "Could not bind checker shader";
         return;
     }
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     // FIXME: It may be better to have the projection in device pixel, but
     //       this requires introducing a new coordinate system.
     projectionMatrix.ortho(0, widgetSize.width(), widgetSize.height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(modelTransform);
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->checkerShader->setUniformValue(d->checkerShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     QMatrix4x4 textureMatrix(textureTransform);
     d->checkerShader->setUniformValue(d->checkerShader->location(Uniform::TextureMatrix), textureMatrix);
 
     //Setup the geometry for rendering
     if (KisOpenGL::hasOpenGL3()) {
         rectToVertices(d->vertices, modelRect);
         d->quadBuffers[0].bind();
         d->quadBuffers[0].write(0, d->vertices, 3 * 6 * sizeof(float));
 
         rectToTexCoords(d->texCoords, textureRect);
         d->quadBuffers[1].bind();
         d->quadBuffers[1].write(0, d->texCoords, 2 * 6 * sizeof(float));
     }
     else {
         rectToVertices(d->vertices, modelRect);
         d->checkerShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
         d->checkerShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, d->vertices);
 
         rectToTexCoords(d->texCoords, textureRect);
         d->checkerShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
         d->checkerShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, d->texCoords);
     }
 
     // render checkers
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, d->openGLImageTextures->checkerTexture());
 
     glDrawArrays(GL_TRIANGLES, 0, 6);
 
     glBindTexture(GL_TEXTURE_2D, 0);
     d->checkerShader->release();
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
 
 void KisOpenGLCanvas2::drawGrid()
 {
     if (!d->solidColorShader->bind()) {
         return;
     }
 
     QSizeF widgetSize = widgetSizeAlignedToDevicePixel();
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     // FIXME: It may be better to have the projection in device pixel, but
     //       this requires introducing a new coordinate system.
     projectionMatrix.ortho(0, widgetSize.width(), widgetSize.height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(coordinatesConverter()->imageToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->solidColorShader->setUniformValue(d->solidColorShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     d->solidColorShader->setUniformValue(
                 d->solidColorShader->location(Uniform::FragmentColor),
                 QVector4D(d->gridColor.redF(), d->gridColor.greenF(), d->gridColor.blueF(), 0.5f));
 
     if (KisOpenGL::hasOpenGL3()) {
         d->outlineVAO.bind();
         d->lineBuffer.bind();
     }
 
     QRectF widgetRect(0,0, widgetSize.width(), widgetSize.height());
     QRectF widgetRectInImagePixels = coordinatesConverter()->documentToImage(coordinatesConverter()->widgetToDocument(widgetRect));
     QRect wr = widgetRectInImagePixels.toAlignedRect();
 
     if (!d->wrapAroundMode) {
         wr &= d->openGLImageTextures->storedImageBounds();
     }
 
     QPoint topLeftCorner = wr.topLeft();
     QPoint bottomRightCorner = wr.bottomRight() + QPoint(1, 1);
     QVector<QVector3D> grid;
 
     for (int i = topLeftCorner.x(); i <= bottomRightCorner.x(); ++i) {
         grid.append(QVector3D(i, topLeftCorner.y(), 0));
         grid.append(QVector3D(i, bottomRightCorner.y(), 0));
     }
     for (int i = topLeftCorner.y(); i <= bottomRightCorner.y(); ++i) {
         grid.append(QVector3D(topLeftCorner.x(), i, 0));
         grid.append(QVector3D(bottomRightCorner.x(), i, 0));
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.allocate(grid.constData(), 3 * grid.size() * sizeof(float));
     }
     else {
         d->solidColorShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
         d->solidColorShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, grid.constData());
     }
 
     glDrawArrays(GL_LINES, 0, grid.size());
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.release();
         d->outlineVAO.release();
     }
 
     d->solidColorShader->release();
     glDisable(GL_BLEND);
 }
 
 void KisOpenGLCanvas2::drawImage()
 {
     if (!d->displayShader) {
         return;
     }
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     KisCoordinatesConverter *converter = coordinatesConverter();
 
     d->displayShader->bind();
 
     QSizeF widgetSize = widgetSizeAlignedToDevicePixel();
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     // FIXME: It may be better to have the projection in device pixel, but
     //       this requires introducing a new coordinate system.
     projectionMatrix.ortho(0, widgetSize.width(), widgetSize.height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(converter->imageToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     QMatrix4x4 textureMatrix;
     textureMatrix.setToIdentity();
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::TextureMatrix), textureMatrix);
 
     QRectF widgetRect(0,0, widgetSize.width(), widgetSize.height());
     QRectF widgetRectInImagePixels = converter->documentToImage(converter->widgetToDocument(widgetRect));
 
     const QRect renderingLimit = canvas()->renderingLimit();
 
     if (!renderingLimit.isEmpty()) {
         widgetRectInImagePixels &= renderingLimit;
     }
 
     qreal scaleX, scaleY;
     converter->imagePhysicalScale(&scaleX, &scaleY);
 
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::ViewportScale), (GLfloat) scaleX);
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::TexelSize), (GLfloat) d->openGLImageTextures->texelSize());
 
     QRect ir = d->openGLImageTextures->storedImageBounds();
     QRect wr = widgetRectInImagePixels.toAlignedRect();
 
     if (!d->wrapAroundMode) {
         // if we don't want to paint wrapping images, just limit the
         // processing area, and the code will handle all the rest
         wr &= ir;
     }
 
     int firstColumn = d->xToColWithWrapCompensation(wr.left(), ir);
     int lastColumn = d->xToColWithWrapCompensation(wr.right(), ir);
     int firstRow = d->yToRowWithWrapCompensation(wr.top(), ir);
     int lastRow = d->yToRowWithWrapCompensation(wr.bottom(), ir);
 
     int minColumn = d->openGLImageTextures->xToCol(ir.left());
     int maxColumn = d->openGLImageTextures->xToCol(ir.right());
     int minRow = d->openGLImageTextures->yToRow(ir.top());
     int maxRow = d->openGLImageTextures->yToRow(ir.bottom());
 
     int imageColumns = maxColumn - minColumn + 1;
     int imageRows = maxRow - minRow + 1;
 
     for (int col = firstColumn; col <= lastColumn; col++) {
         for (int row = firstRow; row <= lastRow; row++) {
 
             int effectiveCol = col;
             int effectiveRow = row;
             QPointF tileWrappingTranslation;
 
             if (effectiveCol > maxColumn || effectiveCol < minColumn) {
                 int translationStep = floor(qreal(col) / imageColumns);
                 int originCol = translationStep * imageColumns;
                 effectiveCol = col - originCol;
                 tileWrappingTranslation.rx() = translationStep * ir.width();
             }
 
             if (effectiveRow > maxRow || effectiveRow < minRow) {
                 int translationStep = floor(qreal(row) / imageRows);
                 int originRow = translationStep * imageRows;
                 effectiveRow = row - originRow;
                 tileWrappingTranslation.ry() = translationStep * ir.height();
             }
 
             KisTextureTile *tile =
                     d->openGLImageTextures->getTextureTileCR(effectiveCol, effectiveRow);
 
             if (!tile) {
                 warnUI << "OpenGL: Trying to paint texture tile but it has not been created yet.";
                 continue;
             }
 
             /*
              * We create a float rect here to workaround Qt's
              * "history reasons" in calculation of right()
              * and bottom() coordinates of integer rects.
              */
 
             QRectF textureRect;
             QRectF modelRect;
 
             if (renderingLimit.isEmpty()) {
                 textureRect = tile->tileRectInTexturePixels();
                 modelRect = tile->tileRectInImagePixels().translated(tileWrappingTranslation.x(), tileWrappingTranslation.y());
             } else {
                 const QRect limitedTileRect = tile->tileRectInImagePixels() & renderingLimit;
                 textureRect = tile->imageRectInTexturePixels(limitedTileRect);
                 modelRect = limitedTileRect.translated(tileWrappingTranslation.x(), tileWrappingTranslation.y());
             }
 
             //Setup the geometry for rendering
             if (KisOpenGL::hasOpenGL3()) {
                 rectToVertices(d->vertices, modelRect);
                 d->quadBuffers[0].bind();
                 d->quadBuffers[0].write(0, d->vertices, 3 * 6 * sizeof(float));
 
                 rectToTexCoords(d->texCoords, textureRect);
                 d->quadBuffers[1].bind();
                 d->quadBuffers[1].write(0, d->texCoords, 2 * 6 * sizeof(float));
             }
             else {
                 rectToVertices(d->vertices, modelRect);
                 d->displayShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
                 d->displayShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, d->vertices);
 
                 rectToTexCoords(d->texCoords, textureRect);
                 d->displayShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
                 d->displayShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, d->texCoords);
             }
 
             if (d->displayFilter) {
                 glActiveTexture(GL_TEXTURE0 + 1);
                 glBindTexture(GL_TEXTURE_3D, d->displayFilter->lutTexture());
                 d->displayShader->setUniformValue(d->displayShader->location(Uniform::Texture1), 1);
             }
 
             glActiveTexture(GL_TEXTURE0);
 
             const int currentLodPlane = tile->bindToActiveTexture(d->lodSwitchInProgress);
 
             if (d->displayShader->location(Uniform::FixedLodLevel) >= 0) {
                 d->displayShader->setUniformValue(d->displayShader->location(Uniform::FixedLodLevel),
                                                   (GLfloat) currentLodPlane);
             }
 
             if (currentLodPlane > 0) {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
             } else if (SCALE_MORE_OR_EQUAL_TO(scaleX, scaleY, 2.0)) {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
             } else {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
                 switch(d->filterMode) {
                 case KisOpenGL::NearestFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                     break;
                 case KisOpenGL::BilinearFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                     break;
                 case KisOpenGL::TrilinearFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                     break;
                 case KisOpenGL::HighQualityFiltering:
                     if (SCALE_LESS_THAN(scaleX, scaleY, 0.5)) {
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
                     } else {
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                     }
                     break;
                 }
             }
 
             glDrawArrays(GL_TRIANGLES, 0, 6);
         }
     }
 
     glBindTexture(GL_TEXTURE_2D, 0);
     d->displayShader->release();
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glDisable(GL_BLEND);
 }
 
 QSize KisOpenGLCanvas2::viewportDevicePixelSize() const
 {
     // This is how QOpenGLCanvas sets the FBO and the viewport size. If
     // devicePixelRatioF() is non-integral, the result is truncated.
     int viewportWidth = static_cast<int>(width() * devicePixelRatioF());
     int viewportHeight = static_cast<int>(height() * devicePixelRatioF());
     return QSize(viewportWidth, viewportHeight);
 }
 
 QSizeF KisOpenGLCanvas2::widgetSizeAlignedToDevicePixel() const
 {
     QSize viewportSize = viewportDevicePixelSize();
     qreal scaledWidth = viewportSize.width() / devicePixelRatioF();
     qreal scaledHeight = viewportSize.height() / devicePixelRatioF();
     return QSizeF(scaledWidth, scaledHeight);
 }
 
 void KisOpenGLCanvas2::slotConfigChanged()
 {
     KisConfig cfg(true);
     d->checkSizeScale = KisOpenGLImageTextures::BACKGROUND_TEXTURE_CHECK_SIZE / static_cast<GLfloat>(cfg.checkSize());
     d->scrollCheckers = cfg.scrollCheckers();
 
     d->openGLImageTextures->generateCheckerTexture(createCheckersImage(cfg.checkSize()));
     d->openGLImageTextures->updateConfig(cfg.useOpenGLTextureBuffer(), cfg.numMipmapLevels());
     d->filterMode = (KisOpenGL::FilterMode) cfg.openGLFilteringMode();
 
     d->cursorColor = cfg.getCursorMainColor();
 
     notifyConfigChanged();
 }
 
 void KisOpenGLCanvas2::slotPixelGridModeChanged()
 {
     KisConfig cfg(true);
 
     d->pixelGridDrawingThreshold = cfg.getPixelGridDrawingThreshold();
     d->pixelGridEnabled = cfg.pixelGridEnabled();
     d->gridColor = cfg.getPixelGridColor();
 
     update();
 }
 
 QVariant KisOpenGLCanvas2::inputMethodQuery(Qt::InputMethodQuery query) const
 {
     return processInputMethodQuery(query);
 }
 
 void KisOpenGLCanvas2::inputMethodEvent(QInputMethodEvent *event)
 {
     processInputMethodEvent(event);
 }
 
 void KisOpenGLCanvas2::renderCanvasGL()
 {
     {
         // Draw the border (that is, clear the whole widget to the border color)
         QColor widgetBackgroundColor = borderColor();
         KoColor convertedBackgroudColor =
             canvas()->displayColorConverter()->applyDisplayFiltering(
                 KoColor(widgetBackgroundColor, KoColorSpaceRegistry::instance()->rgb8()),
                 Float32BitsColorDepthID);
         const float *pixel = reinterpret_cast<const float*>(convertedBackgroudColor.data());
         glClearColor(pixel[0], pixel[1], pixel[2], 1.0);
     }
 
     glClear(GL_COLOR_BUFFER_BIT);
 
     if ((d->displayFilter && d->displayFilter->updateShader()) ||
         (bool(d->displayFilter) != d->displayShaderCompiledWithDisplayFilterSupport)) {
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(d->canvasInitialized);
 
         d->canvasInitialized = false; // TODO: check if actually needed?
         initializeDisplayShader();
         d->canvasInitialized = true;
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.bind();
     }
 
     drawCheckers();
     drawImage();
     if ((coordinatesConverter()->effectiveZoom() > d->pixelGridDrawingThreshold - 0.00001) && d->pixelGridEnabled) {
         drawGrid();
     }
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.release();
     }
 }
 
 void KisOpenGLCanvas2::renderDecorations(QPainter *painter)
 {
     QRect boundingRect = coordinatesConverter()->imageRectInWidgetPixels().toAlignedRect();
     drawDecorations(*painter, boundingRect);
 }
 
 
 void KisOpenGLCanvas2::setDisplayColorConverter(KisDisplayColorConverter *colorConverter)
 {
     d->openGLImageTextures->setMonitorProfile(colorConverter->openGLCanvasSurfaceProfile(),
                                               colorConverter->renderingIntent(),
                                               colorConverter->conversionFlags());
 }
 
 void KisOpenGLCanvas2::channelSelectionChanged(const QBitArray &channelFlags)
 {
     d->openGLImageTextures->setChannelFlags(channelFlags);
 }
 
 
 void KisOpenGLCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     if (d->canvasInitialized) {
         d->openGLImageTextures->slotImageSizeChanged(w, h);
     }
 }
 
 KisUpdateInfoSP KisOpenGLCanvas2::startUpdateCanvasProjection(const QRect & rc, const QBitArray &channelFlags)
 {
     d->openGLImageTextures->setChannelFlags(channelFlags);
     if (canvas()->proofingConfigUpdated()) {
         d->openGLImageTextures->setProofingConfig(canvas()->proofingConfiguration());
         canvas()->setProofingConfigUpdated(false);
     }
     return d->openGLImageTextures->updateCache(rc, d->openGLImageTextures->image());
 }
 
 
 QRect KisOpenGLCanvas2::updateCanvasProjection(KisUpdateInfoSP info)
 {
     // See KisQPainterCanvas::updateCanvasProjection for more info
     bool isOpenGLUpdateInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
     if (isOpenGLUpdateInfo) {
         d->openGLImageTextures->recalculateCache(info, d->lodSwitchInProgress);
     }
     return QRect(); // FIXME: Implement dirty rect for OpenGL
 }
 
 QVector<QRect> KisOpenGLCanvas2::updateCanvasProjection(const QVector<KisUpdateInfoSP> &infoObjects)
 {
 #ifdef Q_OS_MACOS
     /**
      * On OSX openGL defferent (shared) contexts have different execution queues.
      * It means that the textures uploading and their painting can be easily reordered.
      * To overcome the issue, we should ensure that the textures are uploaded in the
      * same openGL context as the painting is done.
      */
 
     QOpenGLContext *oldContext = QOpenGLContext::currentContext();
     QSurface *oldSurface = oldContext ? oldContext->surface() : 0;
 
     this->makeCurrent();
 #endif
 
     QVector<QRect> result = KisCanvasWidgetBase::updateCanvasProjection(infoObjects);
 
 #ifdef Q_OS_MACOS
     if (oldContext) {
         oldContext->makeCurrent(oldSurface);
     } else {
         this->doneCurrent();
     }
 #endif
 
     return result;
 }
 
 bool KisOpenGLCanvas2::callFocusNextPrevChild(bool next)
 {
     return focusNextPrevChild(next);
 }
 
 KisOpenGLImageTexturesSP KisOpenGLCanvas2::openGLImageTextures() const
 {
     return d->openGLImageTextures;
 }
diff --git a/libs/ui/tests/kis_derived_resources_test.cpp b/libs/ui/tests/kis_derived_resources_test.cpp
index c6bd59d4f9..75ca6abf65 100644
--- a/libs/ui/tests/kis_derived_resources_test.cpp
+++ b/libs/ui/tests/kis_derived_resources_test.cpp
@@ -1,159 +1,159 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_derived_resources_test.h"
 
 #include <QTest>
 #include <brushengine/kis_paintop_preset.h>
 
 #include <QApplication>
 
 #include <KoCanvasResourceProvider.h>
 
 #include "kis_canvas_resource_provider.h"
 #include <util.h>
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <KisPart.h>
 #include <KisView.h>
 #include <KisViewManager.h>
 #include <kis_paintop_settings.h>
 #include <KoResourcePaths.h>
 #include <kis_config.h>
 #include "testutil.h"
 #include "opengl/kis_opengl.h"
 
 
 void addResourceTypes()
 {
     // All Krita's resource types
     KoResourcePaths::addResourceType("gmic_definitions", "data", "/gmic/");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/color/icc");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/profiles/");
     KoResourcePaths::addResourceType("kis_actions", "data", "/actions");
     KoResourcePaths::addResourceType("kis_brushes", "data", "/brushes/");
     KoResourcePaths::addResourceType("kis_defaultpresets", "data", "/defaultpresets/");
     KoResourcePaths::addResourceType("kis_images", "data", "/images/");
     KoResourcePaths::addResourceType("kis_paintoppresets", "data", "/paintoppresets/");
     KoResourcePaths::addResourceType("kis_pics", "data", "/pics/");
     KoResourcePaths::addResourceType("kis_resourcebundles", "data", "/bundles/");
     KoResourcePaths::addResourceType("kis_shortcuts", "data", "/shortcuts/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_windowlayouts", "data", "/windowlayouts/");
     KoResourcePaths::addResourceType("kis_workspaces", "data", "/workspaces/");
     KoResourcePaths::addResourceType("ko_effects", "data", "/effects/");
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/");
     KoResourcePaths::addResourceType("ko_palettes", "data", "/palettes/");
     KoResourcePaths::addResourceType("ko_patterns", "data", "/patterns/");
     KoResourcePaths::addResourceType("metadata_schema", "data", "/metadata/schemas/");
     KoResourcePaths::addResourceType("psd_layer_style_collections", "data", "/asl");
     KoResourcePaths::addResourceType("tags", "data", "/tags/");
 
     KisOpenGL::testingInitializeDefaultSurfaceFormat();
 
     KisConfig cfg(false);
-    cfg.setUseOpenGL(false);
+    cfg.disableOpenGL();
 }
 
 void KisDerivedResourcesTest::test()
 {
     addResourceTypes();
 
     KisDocument* doc = createEmptyDocument();
 
 
 
     KisMainWindow* mainWindow = KisPart::instance()->createMainWindow();
     QPointer<KisView> view = new KisView(doc, mainWindow->resourceManager(), mainWindow->actionCollection(), mainWindow);
     KisViewManager *viewManager = new KisViewManager(mainWindow, mainWindow->actionCollection());
     KoCanvasResourceProvider *manager = viewManager->canvasResourceProvider()->resourceManager();
 
     QApplication::processEvents();
 
     QString presetFileName = "autobrush_300px.kpp";
 
     QVariant i;
 
     KisPaintOpPresetSP preset;
     if (!presetFileName.isEmpty()) {
         QString fullFileName = TestUtil::fetchDataFileLazy(presetFileName);
         preset = new KisPaintOpPreset(fullFileName);
         bool presetValid = preset->load();
         Q_ASSERT(presetValid); Q_UNUSED(presetValid);
 
         i.setValue(preset);
 
     }
 
     QVERIFY(i.isValid());
 
     QSignalSpy spy(manager, SIGNAL(canvasResourceChanged(int,QVariant)));
 
     manager->setResource(KisCanvasResourceProvider::CurrentPaintOpPreset, i);
 
     QMap<int, QVariant> expectedSignals;
     expectedSignals[KisCanvasResourceProvider::CurrentPaintOpPreset] = QVariant::fromValue(preset);
     expectedSignals[KisCanvasResourceProvider::EraserMode] = false;
     expectedSignals[KisCanvasResourceProvider::LodSizeThresholdSupported] = true;
     expectedSignals[KisCanvasResourceProvider::EffectiveLodAvailablility] = true;
     expectedSignals[KisCanvasResourceProvider::LodSizeThreshold] = 100;
     expectedSignals[KisCanvasResourceProvider::LodAvailability] = true;
     expectedSignals[KisCanvasResourceProvider::Opacity] = 1.0;
     expectedSignals[KisCanvasResourceProvider::Size] = 300.0;
     expectedSignals[KisCanvasResourceProvider::Flow] = 1.0;
     expectedSignals[KisCanvasResourceProvider::CurrentEffectiveCompositeOp] = COMPOSITE_OVER;
     expectedSignals[KisCanvasResourceProvider::CurrentCompositeOp] = COMPOSITE_OVER;
 
     auto it = spy.begin();
     for (; it != spy.end(); ++it) {
         const int id = (*it)[0].toInt();
         const QVariant value = (*it)[1];
 
         if (!expectedSignals.contains(id)) {
             qDebug() << ppVar(id) << ppVar(value);
             QFAIL("Unexpected signal!");
         } else {
             if (expectedSignals[id] != value) {
                 qDebug() << ppVar(id) << ppVar(value) << ppVar(expectedSignals[id]);
                 QFAIL("Unexpected value!");
             }
         }
     }
 
     QCOMPARE(spy.size(), expectedSignals.size());
 
     spy.clear();
 
     preset->settings()->setPaintOpOpacity(0.8);
 
     QCOMPARE(spy.size(), 1);
     QCOMPARE(spy[0][0].toInt(), (int)KisCanvasResourceProvider::Opacity);
     QCOMPARE(spy[0][1].toDouble(), 0.8);
     spy.clear();
 
 
     mainWindow->hide();
     QApplication::processEvents();
 
     delete view;
     delete doc;
     delete mainWindow;
 }
 
 KISTEST_MAIN(KisDerivedResourcesTest)