diff --git a/krita/ui/KisView.cpp b/krita/ui/KisView.cpp
index 26dfc331ac..0ca8281053 100644
--- a/krita/ui/KisView.cpp
+++ b/krita/ui/KisView.cpp
@@ -1,1009 +1,1007 @@
 /*
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * 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 "KisView.h"
 
 #include "KisView_p.h"
 
 #include <KoDockFactoryBase.h>
 #include <KoDockRegistry.h>
 #include <KoDocumentInfo.h>
 #include "KoDocumentInfo.h"
 #include "KoPageLayout.h"
 #include <KoToolManager.h>
 
 #include <kis_icon.h>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kselectaction.h>
 #include <kconfiggroup.h>
 #include <kactioncollection.h>
 
 #include <QMenu>
 #include <QMessageBox>
 #include <QUrl>
 #include <QTemporaryFile>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QImage>
 #include <QList>
 #include <QPrintDialog>
 #include <QToolBar>
 #include <QUrl>
 #include <QStatusBar>
-#include <QOpenGLContext>
-#include <QOpenGLFunctions>
 #include <QMoveEvent>
 
 #include <kis_image.h>
 #include <kis_node.h>
 #include <kis_group_layer.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_selection.h>
 
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_config.h"
 #include "KisDocument.h"
 #include "kis_image_manager.h"
 #include "KisMainWindow.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_axis.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_shape_controller.h"
 #include "kis_tool_freehand.h"
 #include "KisUndoStackAction.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "kis_composite_progress_proxy.h"
 #include "kis_statusbar.h"
 #include "kis_painting_assistants_decoration.h"
 #include "kis_progress_widget.h"
 #include "kis_signal_compressor.h"
 #include "kis_filter_manager.h"
 #include "krita/gemini/ViewModeSwitchEvent.h"
 #include "krita_utils.h"
 
 
 //static
 QString KisView::newObjectName()
 {
     static int s_viewIFNumber = 0;
     QString name; name.setNum(s_viewIFNumber++); name.prepend("view_");
     return name;
 }
 
 bool KisView::s_firstView = true;
 
 class Q_DECL_HIDDEN KisView::Private
 {
 public:
     Private(KisView *_q, KisDocument *document,
             KoCanvasResourceManager *resourceManager,
             KActionCollection *actionCollection)
         : actionCollection(actionCollection)
         , viewConverter()
         , canvasController(_q, actionCollection)
         , canvas(&viewConverter, resourceManager, _q, document->shapeController())
         , zoomManager(_q, &this->viewConverter, &this->canvasController)
         , paintingAssistantsDecoration(_q)
         , floatingMessageCompressor(100, KisSignalCompressor::POSTPONE)
     {
     }
 
     KisUndoStackAction *undo = 0;
     KisUndoStackAction *redo = 0;
 
     class StatusBarItem;
 
     QList<StatusBarItem> statusBarItems; // Our statusbar items
     bool inOperation; //in the middle of an operation (no screen refreshing)?
 
     QPointer<KisDocument> document; // our KisDocument
     QWidget *tempActiveWidget = 0;
 
     /**
      * Signals the document has been deleted. Can't use document==0 since this
      * only happens in ~QObject, and views get deleted by ~KisDocument.
      * XXX: either provide a better justification to do things this way, or
      * rework the mechanism.
      */
     bool documentDeleted = false;
 
     KActionCollection* actionCollection;
     KisCoordinatesConverter viewConverter;
     KisCanvasController canvasController;
     KisCanvas2 canvas;
     KisZoomManager zoomManager;
     KisViewManager *viewManager = 0;
     KisNodeSP currentNode;
     KisPaintingAssistantsDecoration paintingAssistantsDecoration;
     bool isCurrent = false;
     bool showFloatingMessage = false;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     KisSignalCompressor floatingMessageCompressor;
 
     // Hmm sorry for polluting the private class with such a big inner class.
     // At the beginning it was a little struct :)
     class StatusBarItem
     {
     public:
 
         StatusBarItem(QWidget * widget, int stretch, bool permanent)
             : m_widget(widget),
               m_stretch(stretch),
               m_permanent(permanent),
               m_connected(false),
               m_hidden(false) {}
 
         bool operator==(const StatusBarItem& rhs) {
             return m_widget == rhs.m_widget;
         }
 
         bool operator!=(const StatusBarItem& rhs) {
             return m_widget != rhs.m_widget;
         }
 
         QWidget * widget() const {
             return m_widget;
         }
 
         void ensureItemShown(QStatusBar * sb) {
             Q_ASSERT(m_widget);
             if (!m_connected) {
                 if (m_permanent)
                     sb->addPermanentWidget(m_widget, m_stretch);
                 else
                     sb->addWidget(m_widget, m_stretch);
 
                 if(!m_hidden)
                     m_widget->show();
 
                 m_connected = true;
             }
         }
         void ensureItemHidden(QStatusBar * sb) {
             if (m_connected) {
                 m_hidden = m_widget->isHidden();
                 sb->removeWidget(m_widget);
                 m_widget->hide();
                 m_connected = false;
             }
         }
     private:
         QWidget * m_widget = 0;
         int m_stretch;
         bool m_permanent;
         bool m_connected = false;
         bool m_hidden = false;
 
     };
 
 };
 
 KisView::KisView(KisDocument *document, KoCanvasResourceManager *resourceManager, KActionCollection *actionCollection, QWidget *parent)
     : QWidget(parent)
     , d(new Private(this, document, resourceManager, actionCollection))
 {
     Q_ASSERT(document);
     connect(document, SIGNAL(titleModified(QString,bool)), this, SIGNAL(titleModified(QString,bool)));
     setObjectName(newObjectName());
 
     d->document = document;
 
     setFocusPolicy(Qt::StrongFocus);
 
     d->undo = new KisUndoStackAction(d->document->undoStack(), KisUndoStackAction::UNDO);
     d->redo = new KisUndoStackAction(d->document->undoStack(), KisUndoStackAction::RED0);
 
     QStatusBar * sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(const QString&)),
                 this, SLOT(slotActionStatusText(const QString&)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 
     d->canvas.setup();
 
     KisConfig cfg;
 
     d->canvasController.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setDrawShadow(false);
     d->canvasController.setCanvasMode(KoCanvasController::Infinite);
     d->canvasController.setVastScrolling(cfg.vastScrolling());
     d->canvasController.setCanvas(&d->canvas);
 
     d->zoomManager.setup(d->actionCollection);
 
 
     connect(&d->canvasController, SIGNAL(documentSizeChanged()), &d->zoomManager, SLOT(slotScrollAreaSizeChanged()));
     setAcceptDrops(true);
 
     connect(d->document, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
     connect(d->document, SIGNAL(sigSavingFinished()), this, SLOT(slotSavingFinished()));
 
     d->canvas.addDecoration(&d->paintingAssistantsDecoration);
 
     d->showFloatingMessage = cfg.showCanvasMessages();
 }
 
 KisView::~KisView()
 {
     if (d->viewManager) {
         KoProgressProxy *proxy = d->viewManager->statusBar()->progress()->progressProxy();
         KIS_ASSERT_RECOVER_NOOP(proxy);
         image()->compositeProgressProxy()->removeProxy(proxy);
     }
 
     if (d->viewManager->filterManager()->isStrokeRunning()) {
         d->viewManager->filterManager()->cancel();
     }
 
     KisPart::instance()->removeView(this);
     KoToolManager::instance()->removeCanvasController(&d->canvasController);
     delete d;
 }
 
 void KisView::notifyCurrentStateChanged(bool isCurrent)
 {
     d->isCurrent = isCurrent;
 
     if (!d->isCurrent && d->savedFloatingMessage) {
         d->savedFloatingMessage->removeMessage();
     }
 }
 
 void KisView::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisView::showFloatingMessageImpl(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->viewManager) return;
 
     if(d->isCurrent && d->showFloatingMessage && d->viewManager->qtMainWindow()) {
         if (d->savedFloatingMessage) {
             d->savedFloatingMessage->tryOverrideMessage(message, icon, timeout, priority, alignment);
         } else {
             d->savedFloatingMessage = new KisFloatingMessage(message, this->canvasBase()->canvasWidget(), false, timeout, priority, alignment);
             d->savedFloatingMessage->setShowOverParent(true);
             d->savedFloatingMessage->setIcon(icon);
 
             connect(&d->floatingMessageCompressor, SIGNAL(timeout()), d->savedFloatingMessage, SLOT(showMessage()));
             d->floatingMessageCompressor.start();
         }
     }
 }
 
 void KisView::setViewManager(KisViewManager *view)
 {
     d->viewManager = view;
 
     connect(canvasController(), SIGNAL(toolOptionWidgetsChanged(QList<QPointer<QWidget> >)), d->viewManager->mainWindow(), SLOT(newOptionWidgets(QList<QPointer<QWidget> >)));
 
     KoToolManager::instance()->addController(&d->canvasController);
     KoToolManager::instance()->registerToolActions(d->actionCollection, &d->canvasController);
     dynamic_cast<KisShapeController*>(d->document->shapeController())->setInitialShapeForCanvas(&d->canvas);
 
     if (resourceProvider()) {
         resourceProvider()->slotImageSizeChanged();
     }
 
     if (d->viewManager && d->viewManager->nodeManager()) {
         d->viewManager->nodeManager()->nodesUpdated();
     }
 
     connect(image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), this, SLOT(slotImageSizeChanged(const QPointF&, const QPointF&)));
     connect(image(), SIGNAL(sigResolutionChanged(double,double)), this, SLOT(slotImageResolutionChanged()));
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigRemoveNodeAsync(KisNodeSP)),
             SLOT(slotImageNodeRemoved(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueRemoveNode(KisNodeSP)),
             SLOT(slotContinueRemoveNode(KisNodeSP)),
             Qt::AutoConnection);
 
     /*
      * WARNING: Currently we access the global progress bar in two ways:
      * connecting to composite progress proxy (strokes) and creating
      * progress updaters. The latter way should be deprecated in favour
      * of displaying the status of the global strokes queue
      */
     image()->compositeProgressProxy()->addProxy(d->viewManager->statusBar()->progress()->progressProxy());
     connect(d->viewManager->statusBar()->progress(), SIGNAL(sigCancellationRequested()), image(), SLOT(requestStrokeCancellation()));
 
     d->viewManager->updateGUI();
 
     KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
 }
 
 KisViewManager* KisView::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisView::slotImageNodeRemoved(KisNodeSP node)
 {
     emit sigContinueRemoveNode(KritaUtils::nearestNodeAfterRemoval(node));
 }
 
 void KisView::slotContinueRemoveNode(KisNodeSP newActiveNode)
 {
     if (!d->isCurrent) {
         d->currentNode = newActiveNode;
     }
 }
 
 QAction *KisView::undoAction() const
 {
     return d->undo;
 }
 
 QAction *KisView::redoAction() const
 {
     return d->redo;
 }
 
 KoZoomController *KisView::zoomController() const
 {
     return d->zoomManager.zoomController();
 }
 
 KisZoomManager *KisView::zoomManager() const
 {
     return &d->zoomManager;
 }
 
 KisCanvasController *KisView::canvasController() const
 {
     return &d->canvasController;
 }
 
 KisCanvasResourceProvider *KisView::resourceProvider() const
 {
     if (d->viewManager) {
         return d->viewManager->resourceProvider();
     }
     return 0;
 }
 
 KisInputManager* KisView::globalInputManager() const
 {
     return d->viewManager ? d->viewManager->inputManager() : 0;
 }
 
 KisCanvas2 *KisView::canvasBase() const
 {
     return &d->canvas;
 }
 
 KisImageWSP KisView::image() const
 {
     if (d->document) {
         return d->document->image();
     }
     return 0;
 }
 
 KisCoordinatesConverter *KisView::viewConverter() const
 {
     return &d->viewConverter;
 }
 
 void KisView::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasImage()
             || event->mimeData()->hasUrls()
             || event->mimeData()->hasFormat("application/x-krita-node")) {
         event->accept();
 
         // activate view if it should accept the drop
         this->setFocus();
     } else {
         event->ignore();
     }
 }
 
 void KisView::dropEvent(QDropEvent *event)
 {
     KisImageWSP kisimage = image();
     Q_ASSERT(kisimage);
 
     QPoint cursorPos = canvasBase()->coordinatesConverter()->widgetToImage(event->pos()).toPoint();
     QRect imageBounds = kisimage->bounds();
     QPoint pasteCenter;
     bool forceRecenter;
 
     if (event->keyboardModifiers() & Qt::ShiftModifier &&
             imageBounds.contains(cursorPos)) {
 
         pasteCenter = cursorPos;
         forceRecenter = true;
     } else {
         pasteCenter = imageBounds.center();
         forceRecenter = false;
     }
     if (event->mimeData()->hasFormat("application/x-krita-node") ||
             event->mimeData()->hasImage())
     {
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(d->document->shapeController());
 
         QList<KisNodeSP> nodes =
                 KisMimeData::loadNodes(event->mimeData(), imageBounds,
                                        pasteCenter, forceRecenter,
                                        kisimage, kritaShapeController);
 
         Q_FOREACH (KisNodeSP node, nodes) {
             if (node) {
                 KisNodeCommandsAdapter adapter(viewManager());
                 if (!viewManager()->nodeManager()->activeLayer()) {
                     adapter.addNode(node, kisimage->rootLayer() , 0);
                 } else {
                     adapter.addNode(node,
                                     viewManager()->nodeManager()->activeLayer()->parent(),
                                     viewManager()->nodeManager()->activeLayer());
                 }
             }
         }
     }
     else if (event->mimeData()->hasUrls()) {
 
         QList<QUrl> urls = event->mimeData()->urls();
         if (urls.length() > 0) {
 
             QMenu popup;
             popup.setObjectName("drop_popup");
 
             QAction *insertAsNewLayer = new QAction(i18n("Insert as New Layer"), &popup);
             QAction *insertManyLayers = new QAction(i18n("Insert Many Layers"), &popup);
 
             QAction *openInNewDocument = new QAction(i18n("Open in New Document"), &popup);
             QAction *openManyDocuments = new QAction(i18n("Open Many Documents"), &popup);
 
             QAction *cancel = new QAction(i18n("Cancel"), &popup);
 
             popup.addAction(insertAsNewLayer);
             popup.addAction(openInNewDocument);
             popup.addAction(insertManyLayers);
             popup.addAction(openManyDocuments);
 
             insertAsNewLayer->setEnabled(image() && urls.count() == 1);
             openInNewDocument->setEnabled(urls.count() == 1);
             insertManyLayers->setEnabled(image() && urls.count() > 1);
             openManyDocuments->setEnabled(urls.count() > 1);
 
             popup.addSeparator();
             popup.addAction(cancel);
 
             QAction *action = popup.exec(QCursor::pos());
 
             if (action != 0 && action != cancel) {
                 Q_FOREACH (const QUrl &url, urls) {
 
                     if (action == insertAsNewLayer || action == insertManyLayers) {
                         d->viewManager->imageManager()->importImage(url);
                         activateWindow();
                     }
                     else {
                         Q_ASSERT(action == openInNewDocument || action == openManyDocuments);
                         if (mainWindow()) {
                             mainWindow()->openDocument(url);
                         }
                     }
                 }
             }
         }
     }
 
 }
 
 KisDocument *KisView::document() const
 {
     return d->document;
 }
 
 void KisView::setDocument(KisDocument *document)
 {
     d->document->disconnect(this);
     d->document = document;
     QStatusBar *sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(const QString&)),
                 this, SLOT(slotActionStatusText(const QString&)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 }
 
 void KisView::setDocumentDeleted()
 {
     d->documentDeleted = true;
 }
 
 void KisView::addStatusBarItem(QWidget * widget, int stretch, bool permanent)
 {
     Private::StatusBarItem item(widget, stretch, permanent);
     QStatusBar * sb = statusBar();
     if (sb) {
         item.ensureItemShown(sb);
     }
     d->statusBarItems.append(item);
 }
 
 void KisView::removeStatusBarItem(QWidget *widget)
 {
     QStatusBar *sb = statusBar();
 
     int itemCount = d->statusBarItems.count();
     for (int i = itemCount-1; i >= 0; --i) {
         Private::StatusBarItem &sbItem = d->statusBarItems[i];
         if (sbItem.widget() == widget) {
             if (sb) {
                 sbItem.ensureItemHidden(sb);
             }
             d->statusBarItems.removeOne(sbItem);
             break;
         }
     }
 }
 
 
 KoPageLayout KisView::pageLayout() const
 {
     return document()->pageLayout();
 }
 
 QPrintDialog *KisView::createPrintDialog(KisPrintJob *printJob, QWidget *parent)
 {
     Q_UNUSED(parent);
     QPrintDialog *printDialog = new QPrintDialog(&printJob->printer(), this);
     printDialog->setMinMax(printJob->printer().fromPage(), printJob->printer().toPage());
     printDialog->setEnabledOptions(printJob->printDialogOptions());
     return printDialog;
 }
 
 
 KisMainWindow * KisView::mainWindow() const
 {
     return dynamic_cast<KisMainWindow *>(window());
 }
 
 QStatusBar * KisView::statusBar() const
 {
     KisMainWindow *mw = mainWindow();
     return mw ? mw->statusBar() : 0;
 }
 
 void KisView::slotActionStatusText(const QString &text)
 {
     QStatusBar *sb = statusBar();
     if (sb)
         sb->showMessage(text);
 }
 
 void KisView::slotClearStatusText()
 {
     QStatusBar *sb = statusBar();
     if (sb)
         sb->clearMessage();
 }
 
 QList<QAction*> KisView::createChangeUnitActions(bool addPixelUnit)
 {
     UnitActionGroup* unitActions = new UnitActionGroup(d->document, addPixelUnit, this);
     return unitActions->actions();
 }
 
 bool KisView::event(QEvent *event)
 {
     switch(static_cast<int>(event->type()))
     {
     case ViewModeSwitchEvent::AboutToSwitchViewModeEvent: {
         ViewModeSynchronisationObject* syncObject = static_cast<ViewModeSwitchEvent*>(event)->synchronisationObject();
 
         d->canvasController.setFocus();
         qApp->processEvents();
 
         KisCanvasResourceProvider* provider = resourceProvider();
         syncObject->backgroundColor = provider->bgColor();
         syncObject->foregroundColor = provider->fgColor();
         syncObject->exposure = provider->HDRExposure();
         syncObject->gamma = provider->HDRGamma();
         syncObject->compositeOp = provider->currentCompositeOp();
         syncObject->pattern = provider->currentPattern();
         syncObject->gradient = provider->currentGradient();
         syncObject->node = provider->currentNode();
         syncObject->paintOp = provider->currentPreset();
         syncObject->opacity = provider->opacity();
         syncObject->globalAlphaLock = provider->globalAlphaLock();
 
         syncObject->documentOffset = d->canvasController.scrollBarValue() - pos();
         syncObject->zoomLevel = zoomController()->zoomAction()->effectiveZoom();
         syncObject->rotationAngle = canvasBase()->rotationAngle();
 
         syncObject->activeToolId = KoToolManager::instance()->activeToolId();
 
         syncObject->gridData = &document()->gridData();
 
         syncObject->mirrorHorizontal = provider->mirrorHorizontal();
         syncObject->mirrorVertical = provider->mirrorVertical();
         syncObject->mirrorAxesCenter = provider->resourceManager()->resource(KisCanvasResourceProvider::MirrorAxesCenter).toPointF();
 
         KisToolFreehand* tool = qobject_cast<KisToolFreehand*>(KoToolManager::instance()->toolById(canvasBase(), syncObject->activeToolId));
         if(tool) {
             syncObject->smoothingOptions = tool->smoothingOptions();
         }
 
         syncObject->initialized = true;
 
         QMainWindow* mainWindow = qobject_cast<QMainWindow*>(qApp->activeWindow());
         if(mainWindow) {
             QList<QDockWidget*> dockWidgets = mainWindow->findChildren<QDockWidget*>();
             Q_FOREACH (QDockWidget* widget, dockWidgets) {
                 if (widget->isFloating()) {
                     widget->hide();
                 }
             }
         }
 
         return true;
     }
     case ViewModeSwitchEvent::SwitchedToDesktopModeEvent: {
         ViewModeSynchronisationObject* syncObject = static_cast<ViewModeSwitchEvent*>(event)->synchronisationObject();
         d->canvasController.setFocus();
         qApp->processEvents();
 
         if(syncObject->initialized) {
             KisCanvasResourceProvider* provider = resourceProvider();
 
             provider->resourceManager()->setResource(KisCanvasResourceProvider::MirrorAxesCenter, syncObject->mirrorAxesCenter);
             if (provider->mirrorHorizontal() != syncObject->mirrorHorizontal) {
                 QAction* mirrorAction = d->actionCollection->action("hmirror_action");
                 mirrorAction->setChecked(syncObject->mirrorHorizontal);
                 provider->setMirrorHorizontal(syncObject->mirrorHorizontal);
             }
             if (provider->mirrorVertical() != syncObject->mirrorVertical) {
                 QAction* mirrorAction = d->actionCollection->action("vmirror_action");
                 mirrorAction->setChecked(syncObject->mirrorVertical);
                 provider->setMirrorVertical(syncObject->mirrorVertical);
             }
 
             provider->setPaintOpPreset(syncObject->paintOp);
             qApp->processEvents();
 
             KoToolManager::instance()->switchToolRequested(syncObject->activeToolId);
             qApp->processEvents();
 
             KisPaintOpPresetSP preset = canvasBase()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
             preset->settings()->setProperty("CompositeOp", syncObject->compositeOp);
             if(preset->settings()->hasProperty("OpacityValue"))
                 preset->settings()->setProperty("OpacityValue", syncObject->opacity);
             provider->setPaintOpPreset(preset);
 
             provider->setBGColor(syncObject->backgroundColor);
             provider->setFGColor(syncObject->foregroundColor);
             provider->setHDRExposure(syncObject->exposure);
             provider->setHDRGamma(syncObject->gamma);
             provider->slotPatternActivated(syncObject->pattern);
             provider->slotGradientActivated(syncObject->gradient);
             provider->slotNodeActivated(syncObject->node);
             provider->setOpacity(syncObject->opacity);
             provider->setGlobalAlphaLock(syncObject->globalAlphaLock);
             provider->setCurrentCompositeOp(syncObject->compositeOp);
 
             document()->gridData().setGrid(syncObject->gridData->gridX(), syncObject->gridData->gridY());
             document()->gridData().setGridColor(syncObject->gridData->gridColor());
             document()->gridData().setPaintGridInBackground(syncObject->gridData->paintGridInBackground());
             document()->gridData().setShowGrid(syncObject->gridData->showGrid());
             document()->gridData().setSnapToGrid(syncObject->gridData->snapToGrid());
 
             d->actionCollection->action("zoom_in")->trigger();
             qApp->processEvents();
 
 
             QMainWindow* mainWindow = qobject_cast<QMainWindow*>(qApp->activeWindow());
             if(mainWindow) {
                 QList<QDockWidget*> dockWidgets = mainWindow->findChildren<QDockWidget*>();
                 Q_FOREACH (QDockWidget* widget, dockWidgets) {
                     if (widget->isFloating()) {
                         widget->show();
                     }
                 }
             }
 
             zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, syncObject->zoomLevel);
             d->canvasController.rotateCanvas(syncObject->rotationAngle - canvasBase()->rotationAngle());
 
             QPoint newOffset = syncObject->documentOffset + pos();
             qApp->processEvents();
             d->canvasController.setScrollBarValue(newOffset);
 
             KisToolFreehand* tool = qobject_cast<KisToolFreehand*>(KoToolManager::instance()->toolById(canvasBase(), syncObject->activeToolId));
             if(tool && syncObject->smoothingOptions) {
                 tool->smoothingOptions()->setSmoothingType(syncObject->smoothingOptions->smoothingType());
                 tool->smoothingOptions()->setSmoothPressure(syncObject->smoothingOptions->smoothPressure());
                 tool->smoothingOptions()->setTailAggressiveness(syncObject->smoothingOptions->tailAggressiveness());
                 tool->smoothingOptions()->setUseScalableDistance(syncObject->smoothingOptions->useScalableDistance());
                 tool->smoothingOptions()->setSmoothnessDistance(syncObject->smoothingOptions->smoothnessDistance());
                 tool->smoothingOptions()->setUseDelayDistance(syncObject->smoothingOptions->useDelayDistance());
                 tool->smoothingOptions()->setDelayDistance(syncObject->smoothingOptions->delayDistance());
                 tool->smoothingOptions()->setFinishStabilizedCurve(syncObject->smoothingOptions->finishStabilizedCurve());
                 tool->smoothingOptions()->setStabilizeSensors(syncObject->smoothingOptions->stabilizeSensors());
                 tool->updateSettingsViews();
             }
         }
 
         return true;
     }
     default:
         break;
     }
 
     return QWidget::event( event );
 }
 
 void KisView::closeEvent(QCloseEvent *event)
 {
     // Check whether we're the last view
     int viewCount = KisPart::instance()->viewCount(document());
     if (viewCount > 1) {
         // there are others still, so don't bother the user
         event->accept();
         return;
     }
 
     if (queryClose()) {
         d->viewManager->removeStatusBarItem(zoomManager()->zoomActionWidget());
         event->accept();
         return;
     }
 
     event->ignore();
 
 }
 
 bool KisView::queryClose()
 {
     if (!document())
         return true;
 
     if (document()->isModified()) {
         QString name;
         if (document()->documentInfo()) {
             name = document()->documentInfo()->aboutInfo("title");
         }
         if (name.isEmpty())
             name = document()->url().fileName();
 
         if (name.isEmpty())
             name = i18n("Untitled");
 
         int res = QMessageBox::warning(this,
                                        i18nc("@title:window", "Krita"),
                                        i18n("<p>The document <b>'%1'</b> has been modified.</p><p>Do you want to save it?</p>", name),
                                        QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
 
         switch (res) {
         case QMessageBox::Yes : {
             bool isNative = (document()->outputMimeType() == document()->nativeFormatMimeType());
             if (!viewManager()->mainWindow()->saveDocument(document(), !isNative))
                 return false;
             break;
         }
         case QMessageBox::No :
             document()->removeAutoSaveFiles();
             document()->setModified(false);   // Now when queryClose() is called by closeEvent it won't do anything.
             break;
         default : // case QMessageBox::Cancel :
             return false;
         }
     }
 
     return true;
 
 }
 
 void KisView::resetImageSizeAndScroll(bool changeCentering,
                                       const QPointF &oldImageStillPoint,
                                       const QPointF &newImageStillPoint)
 {
     const KisCoordinatesConverter *converter = d->canvas.coordinatesConverter();
 
     QPointF oldPreferredCenter = d->canvasController.preferredCenter();
 
     /**
      * Calculating the still point in old coordinates depending on the
      * parameters given
      */
 
     QPointF oldStillPoint;
 
     if (changeCentering) {
         oldStillPoint =
                 converter->imageToWidget(oldImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize oldDocumentSize = d->canvasController.documentSize();
         oldStillPoint = QPointF(0.5 * oldDocumentSize.width(), 0.5 * oldDocumentSize.height());
     }
 
     /**
      * Updating the document size
      */
 
     QSizeF size(image()->width() / image()->xRes(), image()->height() / image()->yRes());
     KoZoomController *zc = d->zoomManager.zoomController();
     zc->setZoom(KoZoomMode::ZOOM_CONSTANT, zc->zoomAction()->effectiveZoom());
     zc->setPageSize(size);
     zc->setDocumentSize(size, true);
 
     /**
      * Calculating the still point in new coordinates depending on the
      * parameters given
      */
 
     QPointF newStillPoint;
 
     if (changeCentering) {
         newStillPoint =
                 converter->imageToWidget(newImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize newDocumentSize = d->canvasController.documentSize();
         newStillPoint = QPointF(0.5 * newDocumentSize.width(), 0.5 * newDocumentSize.height());
     }
 
     d->canvasController.setPreferredCenter(oldPreferredCenter - oldStillPoint + newStillPoint);
 }
 
 void KisView::setCurrentNode(KisNodeSP node)
 {
     d->currentNode = node;
 }
 
 KisNodeSP KisView::currentNode() const
 {
     return d->currentNode;
 }
 
 KisLayerSP KisView::currentLayer() const
 {
     KisNodeSP node;
     KisMaskSP mask = currentMask();
     if (mask) {
         node = mask->parent();
     }
     else {
         node = d->currentNode;
     }
     return dynamic_cast<KisLayer*>(node.data());
 }
 
 KisMaskSP KisView::currentMask() const
 {
     return dynamic_cast<KisMask*>(d->currentNode.data());
 }
 
 KisSelectionSP KisView::selection()
 {
     KisLayerSP layer = currentLayer();
     if (layer)
         return layer->selection(); // falls through to the global
     // selection, or 0 in the end
     if (image()) {
         return image()->globalSelection();
     }
     return 0;
 }
 
 void KisView::slotLoadingFinished()
 {
     if (!document()) return;
 
     /**
      * Cold-start of image size/resolution signals
      */
     slotImageResolutionChanged();
 
     if (image()->locked()) {
         // If this is the first view on the image, the image will have been locked
         // so unlock it.
         image()->blockSignals(false);
         image()->unlock();
     }
 
     Q_FOREACH (KisPaintingAssistant* assist, document()->preLoadedAssistants()) {
         d->paintingAssistantsDecoration.addAssistant(assist);
     }
     d->paintingAssistantsDecoration.setVisible(true);
 
     canvasBase()->initializeImage();
 
     /**
      * Dirty hack alert
      */
     d->zoomManager.zoomController()->setAspectMode(true);
 
     if (viewConverter()) {
         viewConverter()->setZoomMode(KoZoomMode::ZOOM_PAGE);
     }
     connect(image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), this, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)));
     connect(image(), SIGNAL(sigProfileChanged(const KoColorProfile*)), this, SIGNAL(sigProfileChanged(const KoColorProfile*)));
     connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SIGNAL(sigSizeChanged(QPointF,QPointF)));
 
     KisNodeSP activeNode = document()->preActivatedNode();
     document()->setPreActivatedNode(0); // to make sure that we don't keep a reference to a layer the user can later delete.
 
     if (!activeNode) {
         activeNode = image()->rootLayer()->lastChild();
     }
 
     while (activeNode && !activeNode->inherits("KisLayer")) {
         activeNode = activeNode->prevSibling();
     }
 
     setCurrentNode(activeNode);
 }
 
 void KisView::slotSavingFinished()
 {
     if (d->viewManager && d->viewManager->mainWindow()) {
         d->viewManager->mainWindow()->updateCaption();
     }
 }
 
 KisPrintJob * KisView::createPrintJob()
 {
     return new KisPrintJob(image());
 }
 
 void KisView::slotImageResolutionChanged()
 {
     resetImageSizeAndScroll(false);
     zoomManager()->updateGUI();
 
     // update KoUnit value for the document
     if (resourceProvider()) {
         resourceProvider()->resourceManager()->
                 setResource(KoCanvasResourceManager::Unit, d->canvas.unit());
     }
 }
 
 void KisView::slotImageSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint)
 {
     resetImageSizeAndScroll(true, oldStillPoint, newStillPoint);
     zoomManager()->updateGUI();
 }
diff --git a/krita/ui/opengl/kis_opengl_image_textures.cpp b/krita/ui/opengl/kis_opengl_image_textures.cpp
index 47807f65ec..9b3d875d2b 100644
--- a/krita/ui/opengl/kis_opengl_image_textures.cpp
+++ b/krita/ui/opengl/kis_opengl_image_textures.cpp
@@ -1,613 +1,612 @@
 /*
  *  Copyright (c) 2005-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 "opengl/kis_opengl_image_textures.h"
 
 #ifdef HAVE_OPENGL
-#include <QOpenGLWidget>
 #include <QOpenGLFunctions>
 #include <QOpenGLContext>
 
 #include <QMessageBox>
 #include <QApplication>
 #include <QDesktopWidget>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 
 #include "kis_image.h"
 #include "kis_config.h"
 #include "KisPart.h"
 
 #ifdef HAVE_OPENEXR
 #include <half.h>
 #endif
 
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
 
 #ifndef GL_BGRA
 #define GL_BGRA 0x80E1
 #endif
 
 
 KisOpenGLImageTextures::ImageTexturesMap KisOpenGLImageTextures::imageTexturesMap;
 
 KisOpenGLImageTextures::KisOpenGLImageTextures()
     : m_image(0)
     , m_monitorProfile(0)
     , m_tilesDestinationColorSpace(0)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
     , m_allChannelsSelected(true)
     , m_useOcio(false)
     , m_initialized(false)
 {
     KisConfig cfg;
     m_renderingIntent = (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 
     m_conversionFlags = KoColorConversionTransformation::HighQuality;
     if (cfg.useBlackPointCompensation()) m_conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     if (!cfg.allowLCMSOptimization()) m_conversionFlags |= KoColorConversionTransformation::NoOptimization;
 
     m_useOcio = cfg.useOcio();
 }
 
 KisOpenGLImageTextures::KisOpenGLImageTextures(KisImageWSP image,
                                                const KoColorProfile *monitorProfile,
                                                KoColorConversionTransformation::Intent renderingIntent,
                                                KoColorConversionTransformation::ConversionFlags conversionFlags)
     : m_image(image)
     , m_monitorProfile(monitorProfile)
     , m_renderingIntent(renderingIntent)
     , m_conversionFlags(conversionFlags)
     , m_tilesDestinationColorSpace(0)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
     , m_allChannelsSelected(true)
     , m_useOcio(false)
     , m_initialized(false)
 {
     Q_ASSERT(renderingIntent < 4);
 }
 
 void KisOpenGLImageTextures::initGL(QOpenGLFunctions *f) {
     if (f) {
         m_glFuncs = f;
     } else {
         errUI << "Tried to create OpenGLImageTextures with uninitialized QOpenGLFunctions";
     }
 
     getTextureSize(&m_texturesInfo);
     m_glFuncs->glGenTextures(1, &m_checkerTexture);
     createImageTextureTiles();
 
     KisOpenGLUpdateInfoSP info = updateCache(m_image->bounds());
     recalculateCache(info);
 }
 
 KisOpenGLImageTextures::~KisOpenGLImageTextures()
 {
     ImageTexturesMap::iterator it = imageTexturesMap.find(m_image);
     if (it != imageTexturesMap.end()) {
         KisOpenGLImageTextures *textures = it.value();
         if (textures == this) {
             dbgUI << "Removing shared image context from map";
             imageTexturesMap.erase(it);
         }
     }
 
     destroyImageTextureTiles();
     m_glFuncs->glDeleteTextures(1, &m_checkerTexture);
 }
 
 KisImageSP KisOpenGLImageTextures::image() const
 {
     return m_image;
 }
 
 bool KisOpenGLImageTextures::imageCanShareTextures()
 {
     KisConfig cfg;
     if (cfg.useOcio()) return false;
     if (KisPart::instance()->mainwindowCount() == 1) return true;
     if (qApp->desktop()->screenCount() == 1) return true;
     for (int i = 1; i < qApp->desktop()->screenCount(); i++) {
         if (cfg.displayProfile(i) != cfg.displayProfile(i - 1)) {
             return false;
         }
     }
     return true;
 }
 
 KisOpenGLImageTexturesSP KisOpenGLImageTextures::getImageTextures(KisImageWSP image,
                                                                   const KoColorProfile *monitorProfile,
                                                                   KoColorConversionTransformation::Intent renderingIntent,
                                                                   KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (imageCanShareTextures()) {
         ImageTexturesMap::iterator it = imageTexturesMap.find(image);
 
         if (it != imageTexturesMap.end()) {
             KisOpenGLImageTexturesSP textures = it.value();
             textures->setMonitorProfile(monitorProfile, renderingIntent, conversionFlags);
 
             return textures;
         } else {
             KisOpenGLImageTextures *imageTextures = new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
             imageTexturesMap[image] = imageTextures;
             dbgUI << "Added shareable textures to map";
 
             return imageTextures;
         }
     } else {
         return new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
     }
 }
 
 QRect KisOpenGLImageTextures::calculateTileRect(int col, int row) const
 {
     return m_image->bounds() &
             QRect(col * m_texturesInfo.effectiveWidth,
                   row * m_texturesInfo.effectiveHeight,
                   m_texturesInfo.effectiveWidth,
                   m_texturesInfo.effectiveHeight);
 }
 
 void KisOpenGLImageTextures::createImageTextureTiles()
 {
     KisConfig cfg;
 
     destroyImageTextureTiles();
     updateTextureFormat();
 
     m_storedImageBounds = m_image->bounds();
     const int lastCol = xToCol(m_image->width());
     const int lastRow = yToRow(m_image->height());
     if (lastCol == 0) {
       return;
     }
 
     m_numCols = lastCol + 1;
 
     // Default color is transparent black
     const int pixelSize = m_tilesDestinationColorSpace->pixelSize();
     QByteArray emptyTileData((m_texturesInfo.width) * (m_texturesInfo.height) * pixelSize, 0);
 
     KisConfig config;
     KisTextureTile::FilterMode mode = (KisTextureTile::FilterMode)config.openGLFilteringMode();
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
 
         m_initialized = true;
         dbgUI  << "OpenGL: creating texture tiles of size" << m_texturesInfo.height << "x" << m_texturesInfo.width;
 
         for (int row = 0; row <= lastRow; row++) {
             for (int col = 0; col <= lastCol; col++) {
                 QRect tileRect = calculateTileRect(col, row);
 
                 KisTextureTile *tile = new KisTextureTile(tileRect,
                                                         &m_texturesInfo,
                                                         emptyTileData,
                                                         mode,
                                                         cfg.useOpenGLTextureBuffer(),
                                                         cfg.numMipmapLevels(),
                                                         f);
                 m_textureTiles.append(tile);
             }
         }
     }
     else {
         dbgUI << "Tried to init texture tiles without a current OpenGL Context.";
     }
 }
 
 void KisOpenGLImageTextures::destroyImageTextureTiles()
 {
     if(m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         delete tile;
     }
     m_textureTiles.clear();
     m_storedImageBounds = QRect();
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCache(const QRect& rect)
 {
     return updateCacheImpl(rect, true);
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheNoConversion(const QRect& rect)
 {
     return updateCacheImpl(rect, false);
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheImpl(const QRect& rect, bool convertColorSpace)
 {
     const KoColorSpace *dstCS = m_tilesDestinationColorSpace;
 
     ConversionOptions options;
 
     if (convertColorSpace) {
         options = ConversionOptions(dstCS, m_renderingIntent, m_conversionFlags);
     }
 
     KisOpenGLUpdateInfoSP info = new KisOpenGLUpdateInfo(options);
 
     QRect updateRect = rect & m_image->bounds();
     if (updateRect.isEmpty() || !(m_initialized)) return info;
 
     /**
      * Why the rect is artificial? That's easy!
      * It does not represent any real piece of the image. It is
      * intentionally stretched to get through the overlappping
      * stripes of neutrality and poke neighbouring tiles.
      * Thanks to the rect we get the coordinates of all the tiles
      * involved into update process
      */
 
     QRect artificialRect = stretchRect(updateRect, m_texturesInfo.border);
     artificialRect &= m_image->bounds();
 
     int firstColumn = xToCol(artificialRect.left());
     int lastColumn = xToCol(artificialRect.right());
     int firstRow = yToRow(artificialRect.top());
     int lastRow = yToRow(artificialRect.bottom());
 
     QBitArray channelFlags; // empty by default
 
     if (m_channelFlags.size() != m_image->projection()->colorSpace()->channels().size()) {
         setChannelFlags(QBitArray());
     }
     if (!m_useOcio) { // Ocio does its own channel flipping
         if (!m_allChannelsSelected) { // and we do it only if necessary
             channelFlags = m_channelFlags;
         }
     }
 
     qint32 numItems = (lastColumn - firstColumn + 1) * (lastRow - firstRow + 1);
     info->tileList.reserve(numItems);
 
     const QRect bounds = m_image->bounds();
     const int levelOfDetail = m_image->currentLevelOfDetail();
 
     QRect alignedUpdateRect = updateRect;
     QRect alignedBounds = bounds;
 
     if (levelOfDetail) {
         alignedUpdateRect = KisLodTransform::alignedRect(alignedUpdateRect, levelOfDetail);
         alignedBounds = KisLodTransform::alignedRect(alignedBounds, levelOfDetail);
     }
 
     for (int col = firstColumn; col <= lastColumn; col++) {
         for (int row = firstRow; row <= lastRow; row++) {
 
             const QRect tileRect = calculateTileRect(col, row);
             const QRect tileTextureRect = stretchRect(tileRect, m_texturesInfo.border);
 
             QRect alignedTileTextureRect = levelOfDetail ?
                 KisLodTransform::alignedRect(tileTextureRect, levelOfDetail) :
                 tileTextureRect;
 
             KisTextureTileUpdateInfoSP tileInfo(
                 new KisTextureTileUpdateInfo(col, row,
                                              alignedTileTextureRect,
                                              alignedUpdateRect,
                                              alignedBounds,
                                              levelOfDetail));
             // Don't update empty tiles
             if (tileInfo->valid()) {
                 tileInfo->retrieveData(m_image, channelFlags, m_onlyOneChannelSelected, m_selectedChannelIndex);
 
                 if (convertColorSpace) {
                     tileInfo->convertTo(dstCS, m_renderingIntent, m_conversionFlags);
                 }
 
                 info->tileList.append(tileInfo);
             }
             else {
                 dbgUI << "Trying to create an empty tileinfo record" << col << row << tileTextureRect << updateRect << m_image->bounds();
             }
         }
     }
 
     info->assignDirtyImageRect(rect);
     return info;
 }
 
 void KisOpenGLImageTextures::recalculateCache(KisUpdateInfoSP info)
 {
     if (!m_initialized) {
         dbgUI << "OpenGL: Tried to edit image texture cache before it was initialized.";
         return;
     }
 
     KisOpenGLUpdateInfoSP glInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
     if(!glInfo) return;
 
     KisTextureTileUpdateInfoSP tileInfo;
     Q_FOREACH (tileInfo, glInfo->tileList) {
         KisTextureTile *tile = getTextureTileCR(tileInfo->tileCol(), tileInfo->tileRow());
         KIS_ASSERT_RECOVER_RETURN(tile);
 
         tile->update(*tileInfo);
     }
 }
 
 void KisOpenGLImageTextures::generateCheckerTexture(const QImage &checkImage)
 {
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
         dbgUI << "Attaching checker texture" << checkerTexture();
         f->glBindTexture(GL_TEXTURE_2D, checkerTexture());
 
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
         f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
         QImage img = checkImage;
         if (checkImage.width() != BACKGROUND_TEXTURE_SIZE || checkImage.height() != BACKGROUND_TEXTURE_SIZE) {
             img = checkImage.scaled(BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE);
         }
         f->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE,
                     0, GL_BGRA, GL_UNSIGNED_BYTE, img.constBits());
     }
     else {
         dbgUI << "OpenGL: Tried to generate checker texture before OpenGL was initialized.";
     }
 
 }
 
 GLuint KisOpenGLImageTextures::checkerTexture()
 {
     if (m_glFuncs) {
         if (m_checkerTexture == 0) {
             m_glFuncs->glGenTextures(1, &m_checkerTexture);
         }
         return m_checkerTexture;
     }
     else {
         dbgUI << "Tried to access checker texture before OpenGL was initialized";
         return 0;
     }
 }
 
 void KisOpenGLImageTextures::updateConfig(bool useBuffer, int NumMipmapLevels)
 {
     if(m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         tile->setUseBuffer(useBuffer);
         tile->setNumMipmapLevels(NumMipmapLevels);
     }
 }
 
 void KisOpenGLImageTextures::slotImageSizeChanged(qint32 /*w*/, qint32 /*h*/)
 {
     createImageTextureTiles();
 }
 
 void KisOpenGLImageTextures::setMonitorProfile(const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     //dbgUI << "Setting monitor profile to" << monitorProfile->name() << renderingIntent << conversionFlags;
     m_monitorProfile = monitorProfile;
     m_renderingIntent = renderingIntent;
     m_conversionFlags = conversionFlags;
 
     createImageTextureTiles();
 }
 
 void KisOpenGLImageTextures::setChannelFlags(const QBitArray &channelFlags)
 {
     m_channelFlags = channelFlags;
     int selectedChannels = 0;
     const KoColorSpace *projectionCs = m_image->projection()->colorSpace();
     QList<KoChannelInfo*> channelInfo = projectionCs->channels();
 
     if (m_channelFlags.size() != channelInfo.size()) {
         m_channelFlags = QBitArray();
     }
 
     for (int i = 0; i < m_channelFlags.size(); ++i) {
         if (m_channelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
             selectedChannels++;
             m_selectedChannelIndex = i;
         }
     }
     m_allChannelsSelected = (selectedChannels == m_channelFlags.size());
     m_onlyOneChannelSelected = (selectedChannels == 1);
 }
 
 void KisOpenGLImageTextures::getTextureSize(KisGLTexturesInfo *texturesInfo)
 {
     KisConfig cfg;
 
     const GLint preferredTextureSize = cfg.openGLTextureSize();
 
     GLint maxTextureSize;
     if (m_glFuncs) {
         m_glFuncs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
     }
     else {
         dbgUI << "OpenGL: Tried to read texture size before OpenGL was initialized.";
         maxTextureSize = GL_MAX_TEXTURE_SIZE;
     }
 
     texturesInfo->width = qMin(preferredTextureSize, maxTextureSize);
     texturesInfo->height = qMin(preferredTextureSize, maxTextureSize);
 
     texturesInfo->border = cfg.textureOverlapBorder();
 
     texturesInfo->effectiveWidth = texturesInfo->width - 2 * texturesInfo->border;
     texturesInfo->effectiveHeight = texturesInfo->height - 2 * texturesInfo->border;
 }
 
 bool KisOpenGLImageTextures::internalColorManagementActive() const
 {
     return m_internalColorManagementActive;
 }
 
 bool KisOpenGLImageTextures::setInternalColorManagementActive(bool value)
 {
     bool needsFinalRegeneration = m_internalColorManagementActive != value;
 
 
     if (needsFinalRegeneration) {
         m_internalColorManagementActive = value;
         createImageTextureTiles();
 
         // at this point the value of m_internalColorManagementActive might
         // have been forcely reverted to 'false' in case of some problems
     }
 
     return needsFinalRegeneration;
 }
 
 void KisOpenGLImageTextures::updateTextureFormat()
 {
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (!(m_image && ctx)) return;
 
     m_texturesInfo.internalFormat = GL_RGBA8;
     m_texturesInfo.type = GL_UNSIGNED_BYTE;
     m_texturesInfo.format = GL_BGRA;
 
     KoID colorModelId = m_image->colorSpace()->colorModelId();
     KoID colorDepthId = m_image->colorSpace()->colorDepthId();
 
     KoID destinationColorModelId = RGBAColorModelID;
     KoID destinationColorDepthId = Integer8BitsColorDepthID;
 
     dbgUI << "Choosing texture format:";
 
     if (colorModelId == RGBAColorModelID) {
         if (colorDepthId == Float16BitsColorDepthID) {
 
             if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA16F_ARB;
                 dbgUI << "Using ARB half";
             }
             else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT16_ATI;
                 dbgUI << "Using ATI half";
             }
 
             bool haveBuiltInOpenExr = false;
 #ifdef HAVE_OPENEXR
             haveBuiltInOpenExr = true;
 #endif
 
             if (haveBuiltInOpenExr && ctx->hasExtension("GL_ARB_half_float_pixel")) {
                 m_texturesInfo.type = GL_HALF_FLOAT_ARB;
                 destinationColorDepthId = Float16BitsColorDepthID;
                 dbgUI << "Pixel type half";
             } else {
                 m_texturesInfo.type = GL_FLOAT;
                 destinationColorDepthId = Float32BitsColorDepthID;
                 dbgUI << "Pixel type float";
             }
             m_texturesInfo.format = GL_RGBA;
         }
         else if (colorDepthId == Float32BitsColorDepthID) {
             if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA32F_ARB;
                 dbgUI << "Using ARB float";
             } else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT32_ATI;
                 dbgUI << "Using ATI float";
             }
 
             m_texturesInfo.type = GL_FLOAT;
             m_texturesInfo.format = GL_RGBA;
             destinationColorDepthId = Float32BitsColorDepthID;
         }
         else if (colorDepthId == Integer16BitsColorDepthID) {
             m_texturesInfo.internalFormat = GL_RGBA16;
             m_texturesInfo.type = GL_UNSIGNED_SHORT;
             m_texturesInfo.format = GL_BGRA;
             destinationColorDepthId = Integer16BitsColorDepthID;
             dbgUI << "Using 16 bits rgba";
         }
     }
     else {
         // We will convert the colorspace to 16 bits rgba, instead of 8 bits
         if (colorDepthId == Integer16BitsColorDepthID) {
             m_texturesInfo.internalFormat = GL_RGBA16;
             m_texturesInfo.type = GL_UNSIGNED_SHORT;
             m_texturesInfo.format = GL_BGRA;
             destinationColorDepthId = Integer16BitsColorDepthID;
             dbgUI << "Using conversion to 16 bits rgba";
         }
     }
 
     if (!m_internalColorManagementActive &&
         colorModelId != destinationColorModelId) {
 
         KisConfig cfg;
         KisConfig::OcioColorManagementMode cm = cfg.ocioColorManagementMode();
 
         if (cm != KisConfig::INTERNAL) {
             QMessageBox::critical(0,
                                   i18nc("@title:window", "Krita"),
                                   i18n("You enabled OpenColorIO based color management, but your image is not an RGB image.\n"
                                        "OpenColorIO-based color management only works with RGB images.\n"
                                        "Please check the settings in the LUT docker.\n"
                                        "OpenColorIO will now be deactivated."));
         }
 
         warnUI << "WARNING: Internal color management was forcely enabled";
         warnUI << "Color Management Mode: " << cm;
         warnUI << ppVar(m_image->colorSpace());
         warnUI << ppVar(destinationColorModelId);
         warnUI << ppVar(destinationColorDepthId);
 
         cfg.setOcioColorManagementMode(KisConfig::INTERNAL);
         m_internalColorManagementActive = true;
     }
 
     const KoColorProfile *profile =
         m_internalColorManagementActive ||
         colorModelId != destinationColorModelId ?
         m_monitorProfile : m_image->colorSpace()->profile();
 
     /**
      * TODO: add an optimization so that the tile->convertTo() method
      *       would not be called when not needed (DK)
      */
 
     m_tilesDestinationColorSpace =
         KoColorSpaceRegistry::instance()->colorSpace(destinationColorModelId.id(),
                                                      destinationColorDepthId.id(),
                                                      profile);
 }
 
 
 #endif // HAVE_OPENGL