diff --git a/libs/global/KisReadWriteLockPolicy.h b/libs/global/KisReadWriteLockPolicy.h
new file mode 100644
index 0000000000..565e8c4ec3
--- /dev/null
+++ b/libs/global/KisReadWriteLockPolicy.h
@@ -0,0 +1,50 @@
+/*
+ *  Copyright (c) 2017 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.
+ */
+
+#ifndef KISREADWRITELOCKPOLICY_H
+#define KISREADWRITELOCKPOLICY_H
+
+#include <boost/utility.hpp>
+
+#include <QReadLocker>
+#include <QWriteLocker>
+#include "KisUpgradeToWriteLocker.h"
+
+struct NormalLockPolicy {
+    typedef QReadLocker ReadLocker;
+    typedef QWriteLocker WriteLocker;
+};
+
+struct UpgradeLockPolicy {
+    struct FakeLocker : private boost::noncopyable {
+        FakeLocker(QReadWriteLock *) {}
+    };
+
+    typedef FakeLocker ReadLocker;
+    typedef KisUpgradeToWriteLocker WriteLocker;
+};
+
+struct NoLockPolicy {
+    struct FakeLocker : private boost::noncopyable {
+        FakeLocker(QReadWriteLock *) {}
+    };
+
+    typedef FakeLocker ReadLocker;
+    typedef FakeLocker WriteLocker;
+};
+#endif // KISREADWRITELOCKPOLICY_H
diff --git a/libs/global/KisUpgradeToWriteLocker.h b/libs/global/KisUpgradeToWriteLocker.h
new file mode 100644
index 0000000000..edecf80fb6
--- /dev/null
+++ b/libs/global/KisUpgradeToWriteLocker.h
@@ -0,0 +1,55 @@
+/*
+ *  Copyright (c) 2017 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.
+ */
+
+#ifndef KISUPGRADETOWRITELOCKER_H
+#define KISUPGRADETOWRITELOCKER_H
+
+#include <QReadLocker>
+#include <QReadWriteLock>
+
+/**
+ * @brief The KisUpgradeToWriteLocker class is use for RAII style unlocking
+ * the read lock and then locking the lock for write. We basically "upgrade"
+ * the lock to a write one.
+ *
+ * WARNING: during the *upgrade* the lock passes the "unlocked" state, so
+ *          all the protected data you acquired during the "read" phase might
+ *          have become invalidated!
+ */
+class KisUpgradeToWriteLocker
+{
+public:
+    KisUpgradeToWriteLocker(QReadLocker *locker)
+        : m_locker(locker)
+    {
+        m_locker->unlock();
+        m_locker->readWriteLock()->lockForWrite();
+    }
+
+    ~KisUpgradeToWriteLocker() {
+        m_locker->readWriteLock()->unlock();
+        m_locker->relock();
+    }
+
+private:
+    QReadLocker *m_locker;
+};
+
+
+
+#endif // KISUPGRADETOWRITELOCKER_H
diff --git a/libs/pigment/CMakeLists.txt b/libs/pigment/CMakeLists.txt
index c44fcb81c4..b1552b6da6 100644
--- a/libs/pigment/CMakeLists.txt
+++ b/libs/pigment/CMakeLists.txt
@@ -1,122 +1,124 @@
 project(kritapigment)
 
 # we have to repeat platform specifics from top-level
 if (WIN32)
     include_directories(${CMAKE_SOURCE_DIR}/winquirks)
     add_definitions(-D_USE_MATH_DEFINES)
     add_definitions(-DNOMINMAX)
     set(WIN32_PLATFORM_NET_LIBS ws2_32.lib netapi32.lib)
 endif ()
 
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/resources
     ${CMAKE_CURRENT_SOURCE_DIR}/compositeops)
 include_directories(SYSTEM
     ${Boost_INCLUDE_DIRS}
 )
 
 set(FILE_OPENEXR_SOURCES)
 set(LINK_OPENEXR_LIB)
 if(OPENEXR_FOUND)
     include_directories(SYSTEM ${OPENEXR_INCLUDE_DIR})
     set(LINK_OPENEXR_LIB ${OPENEXR_LIBRARIES})
     add_definitions(${OPENEXR_DEFINITIONS})
 endif()
 
 set(LINK_VC_LIB)
 
 if(HAVE_VC)
     include_directories(SYSTEM ${Vc_INCLUDE_DIR})
     set(LINK_VC_LIB ${Vc_LIBRARIES})
     ko_compile_for_all_implementations_no_scalar(__per_arch_factory_objs compositeops/KoOptimizedCompositeOpFactoryPerArch.cpp)
 
     message("Following objects are generated from the per-arch lib")
     message(${__per_arch_factory_objs})
 endif()
 
 add_subdirectory(tests)
 add_subdirectory(benchmarks)
 
 set(kritapigment_SRCS
     DebugPigment.cpp
     KoBasicHistogramProducers.cpp
     KoColor.cpp
     KoColorDisplayRendererInterface.cpp
     KoColorConversionAlphaTransformation.cpp
     KoColorConversionCache.cpp
     KoColorConversions.cpp
     KoColorConversionSystem.cpp
     KoColorConversionTransformation.cpp
     KoColorProofingConversionTransformation.cpp
     KoColorConversionTransformationFactory.cpp
     KoColorModelStandardIds.cpp
     KoColorProfile.cpp
     KoColorSpace.cpp
     KoColorSpaceEngine.cpp
     KoColorSpaceFactory.cpp
     KoColorSpaceMaths.cpp
     KoColorSpaceRegistry.cpp
+    KoColorProfileStorage.cpp
     KoColorTransformation.cpp
     KoColorTransformationFactory.cpp
     KoColorTransformationFactoryRegistry.cpp
     KoCompositeColorTransformation.cpp
     KoCompositeOp.cpp
     KoCompositeOpRegistry.cpp
     KoCopyColorConversionTransformation.cpp
     KoFallBackColorTransformation.cpp
     KoHistogramProducer.cpp
     KoMultipleColorConversionTransformation.cpp
     KoUniqueNumberForIdServer.cpp
     colorspaces/KoAlphaColorSpace.cpp
     colorspaces/KoLabColorSpace.cpp
     colorspaces/KoRgbU16ColorSpace.cpp
     colorspaces/KoRgbU8ColorSpace.cpp
     colorspaces/KoSimpleColorSpaceEngine.cpp
     compositeops/KoOptimizedCompositeOpFactory.cpp
     compositeops/KoOptimizedCompositeOpFactoryPerArch_Scalar.cpp
     ${__per_arch_factory_objs}
     colorprofiles/KoDummyColorProfile.cpp
     resources/KoAbstractGradient.cpp
     resources/KoColorSet.cpp
     resources/KoPattern.cpp
     resources/KoResource.cpp
     resources/KoMD5Generator.cpp
     resources/KoHashGeneratorProvider.cpp
     resources/KoStopGradient.cpp
     resources/KoSegmentGradient.cpp
 )
 
 set (EXTRA_LIBRARIES ${LINK_OPENEXR_LIB} ${LINK_VC_LIB})
 
 if(MSVC OR (WIN32 AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel"))
   # avoid "cannot open file 'LIBC.lib'" error
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /NODEFAULTLIB:LIBC.LIB")
 endif()
 
 add_library(kritapigment SHARED ${kritapigment_SRCS})
 generate_export_header(kritapigment)
 
 target_include_directories( kritapigment
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/resources>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/compositeops>
 )
 
 target_link_libraries( kritapigment
     PUBLIC
         kritaplugin
         kritastore
+        kritaglobal
         ${EXTRA_LIBRARIES}
         KF5::I18n 
         KF5::ConfigCore
         Qt5::Core
         Qt5::Gui
         Qt5::Xml
         ${WIN32_PLATFORM_NET_LIBS}
 )
 
 set_target_properties(kritapigment PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 
 install(TARGETS kritapigment  ${INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/libs/pigment/KoColorConversionSystem.cpp b/libs/pigment/KoColorConversionSystem.cpp
index c55db3a0e7..0344044b11 100644
--- a/libs/pigment/KoColorConversionSystem.cpp
+++ b/libs/pigment/KoColorConversionSystem.cpp
@@ -1,504 +1,505 @@
 /*
  *  Copyright (c) 2007-2008 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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 "KoColorConversionSystem.h"
 #include "KoColorConversionSystem_p.h"
 
 #include <QHash>
 #include <QString>
 
 #include "KoColorConversionAlphaTransformation.h"
 #include "KoColorConversionTransformation.h"
 #include "KoColorProfile.h"
 #include "KoColorSpace.h"
 #include "KoCopyColorConversionTransformation.h"
 #include "KoMultipleColorConversionTransformation.h"
 
 
-KoColorConversionSystem::KoColorConversionSystem() : d(new Private)
+KoColorConversionSystem::KoColorConversionSystem(RegistryInterface *registryInterface)
+    : d(new Private(registryInterface))
 {
 }
 
 KoColorConversionSystem::~KoColorConversionSystem()
 {
     qDeleteAll(d->graph);
     qDeleteAll(d->vertexes);
     delete d;
 }
 
 void KoColorConversionSystem::connectToEngine(Node* _node, Node* _engine)
 {
     Vertex* v1 = createVertex(_node, _engine);
     Vertex* v2 = createVertex(_engine, _node);
     v1->conserveColorInformation = !_node->isGray;
     v2->conserveColorInformation = !_node->isGray;
     v1->conserveDynamicRange = _engine->isHdr;
     v2->conserveDynamicRange = _engine->isHdr;
 }
 
 KoColorConversionSystem::Node* KoColorConversionSystem::insertEngine(const KoColorSpaceEngine* engine)
 {
     NodeKey key(engine->id(), engine->id(), engine->id());
     Node* n = new Node;
     n->modelId = engine->id();
     n->depthId = engine->id();
     n->profileName = engine->id();
     n->referenceDepth = 64; // engine don't have reference depth,
     d->graph.insert(key, n);
     n->init(engine);
     return n;
 }
 
 
 void KoColorConversionSystem::insertColorSpace(const KoColorSpaceFactory* csf)
 {
     dbgPigment << "Inserting color space " << csf->name() << " (" << csf->id() << ") Model: " << csf->colorModelId() << " Depth: " << csf->colorDepthId() << " into the CCS";
-    const QList<const KoColorProfile*> profiles = KoColorSpaceRegistry::instance()->profilesFor(csf);
+    const QList<const KoColorProfile*> profiles = d->registryInterface->profilesFor(csf);
     QString modelId = csf->colorModelId().id();
     QString depthId = csf->colorDepthId().id();
     if (profiles.isEmpty()) { // There is no profile for this CS, create a node without profile name if the color engine isn't icc-based
         if (csf->colorSpaceEngine() != "icc") {
             Node* n = nodeFor(modelId, depthId, "default");
             n->init(csf);
         }
         else {
             dbgPigment << "Cannot add node for " << csf->name() << ", since there are no profiles available";
         }
     } else {
         // Initialise the nodes
         Q_FOREACH (const KoColorProfile* profile, profiles) {
             Node* n = nodeFor(modelId, depthId, profile->name());
             n->init(csf);
             if (!csf->colorSpaceEngine().isEmpty()) {
                 KoColorSpaceEngine* engine = KoColorSpaceEngineRegistry::instance()->get(csf->colorSpaceEngine());
                 Q_ASSERT(engine);
                 NodeKey engineKey(engine->id(), engine->id(), engine->id());
                 Node* engineNode = 0;
                 QHash<NodeKey, Node*>::ConstIterator it = d->graph.constFind(engineKey);
                 if (it != d->graph.constEnd()) {
                     engineNode = it.value();
                 } else {
                     engineNode = insertEngine(engine);
                 }
                 connectToEngine(n, engineNode);
             }
         }
     }
     // Construct a link for "custom" transformation
     const QList<KoColorConversionTransformationFactory*> cctfs = csf->colorConversionLinks();
     Q_FOREACH (KoColorConversionTransformationFactory* cctf, cctfs) {
         Node* srcNode = nodeFor(cctf->srcColorModelId(), cctf->srcColorDepthId(), cctf->srcProfile());
         Q_ASSERT(srcNode);
         Node* dstNode = nodeFor(cctf->dstColorModelId(), cctf->dstColorDepthId(), cctf->dstProfile());
         Q_ASSERT(dstNode);
         // Check if the two nodes are already connected
         Vertex* v = vertexBetween(srcNode, dstNode);
         // If the vertex doesn't already exist, then create it
         if (!v) {
             v = createVertex(srcNode, dstNode);
         }
         Q_ASSERT(v); // we should have one now
         if (dstNode->modelId == modelId && dstNode->depthId == depthId) {
             v->setFactoryFromDst(cctf);
         }
         if (srcNode->modelId == modelId && srcNode->depthId == depthId) {
             v->setFactoryFromSrc(cctf);
         }
     }
 }
 
 void KoColorConversionSystem::insertColorProfile(const KoColorProfile* _profile)
 {
     dbgPigmentCCS << _profile->name();
-    const QList< const KoColorSpaceFactory* >& factories = KoColorSpaceRegistry::instance()->colorSpacesFor(_profile);
+    const QList< const KoColorSpaceFactory* >& factories = d->registryInterface->colorSpacesFor(_profile);
     Q_FOREACH (const KoColorSpaceFactory* factory, factories) {
         QString modelId = factory->colorModelId().id();
         QString depthId = factory->colorDepthId().id();
         Node* n = nodeFor(modelId, depthId, _profile->name());
         n->init(factory);
         if (!factory->colorSpaceEngine().isEmpty()) {
             KoColorSpaceEngine* engine = KoColorSpaceEngineRegistry::instance()->get(factory->colorSpaceEngine());
             Q_ASSERT(engine);
             Node* engineNode = d->graph[ NodeKey(engine->id(), engine->id(), engine->id())];
             Q_ASSERT(engineNode);
             connectToEngine(n, engineNode);
         }
         const QList<KoColorConversionTransformationFactory*> cctfs = factory->colorConversionLinks();
         Q_FOREACH (KoColorConversionTransformationFactory* cctf, cctfs) {
             Node* srcNode = nodeFor(cctf->srcColorModelId(), cctf->srcColorDepthId(), cctf->srcProfile());
             Q_ASSERT(srcNode);
             Node* dstNode = nodeFor(cctf->dstColorModelId(), cctf->dstColorDepthId(), cctf->dstProfile());
             Q_ASSERT(dstNode);
             if (srcNode == n || dstNode == n) {
                 // Check if the two nodes are already connected
                 Vertex* v = vertexBetween(srcNode, dstNode);
                 // If the vertex doesn't already exist, then create it
                 if (!v) {
                     v = createVertex(srcNode, dstNode);
                 }
                 Q_ASSERT(v); // we should have one now
                 if (dstNode->modelId == modelId && dstNode->depthId == depthId) {
                     v->setFactoryFromDst(cctf);
                 }
                 if (srcNode->modelId == modelId && srcNode->depthId == depthId) {
                     v->setFactoryFromSrc(cctf);
                 }
             }
         }
     }
 }
 
 const KoColorSpace* KoColorConversionSystem::defaultColorSpaceForNode(const Node* node) const
 {
-    return KoColorSpaceRegistry::instance()->colorSpace(node->modelId, node->depthId, node->profileName);
+    return d->registryInterface->colorSpace(node->modelId, node->depthId, node->profileName);
 }
 
 KoColorConversionSystem::Node* KoColorConversionSystem::createNode(const QString& _modelId, const QString& _depthId, const QString& _profileName)
 {
     Node* n = new Node;
     n->modelId = _modelId;
     n->depthId = _depthId;
     n->profileName = _profileName;
     d->graph.insert(NodeKey(_modelId, _depthId, _profileName), n);
     return n;
 }
 
 const KoColorConversionSystem::Node* KoColorConversionSystem::nodeFor(const KoColorSpace* _colorSpace) const
 {
     const KoColorProfile* profile = _colorSpace->profile();
     return nodeFor(_colorSpace->colorModelId().id(), _colorSpace->colorDepthId().id(),
                    profile ? profile->name() : "default");
 }
 
 const KoColorConversionSystem::Node* KoColorConversionSystem::nodeFor(const QString& _colorModelId, const QString& _colorDepthId, const QString& _profileName) const
 {
     dbgPigmentCCS << "Look for node: " << _colorModelId << " " << _colorDepthId << " " << _profileName;
     return nodeFor(NodeKey(_colorModelId, _colorDepthId, _profileName));
 }
 
 const KoColorConversionSystem::Node* KoColorConversionSystem::nodeFor(const NodeKey& key) const
 {
     dbgPigmentCCS << "Look for node: " << key.modelId << " " << key.depthId << " " << key.profileName << " " << d->graph.value(key);
     return d->graph.value(key);
 }
 
 KoColorConversionSystem::Node* KoColorConversionSystem::nodeFor(const QString& _colorModelId, const QString& _colorDepthId, const QString& _profileName)
 {
     return nodeFor(NodeKey(_colorModelId, _colorDepthId, _profileName));
 }
 
 KoColorConversionSystem::Node* KoColorConversionSystem::nodeFor(const KoColorConversionSystem::NodeKey& key)
 {
     QHash<NodeKey, Node*>::ConstIterator it = d->graph.constFind(key);
     if (it != d->graph.constEnd()) {
         return it.value();
     } else {
         return createNode(key.modelId, key.depthId, key.profileName);
     }
 }
 
 QList<KoColorConversionSystem::Node*> KoColorConversionSystem::nodesFor(const QString& _modelId, const QString& _depthId)
 {
     QList<Node*> nodes;
     Q_FOREACH (Node* node, d->graph) {
         if (node->modelId == _modelId &&  node->depthId == _depthId) {
             nodes << node;
         }
     }
     return nodes;
 }
 
 KoColorConversionTransformation* KoColorConversionSystem::createColorConverter(const KoColorSpace * srcColorSpace, const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     if (*srcColorSpace == *dstColorSpace) {
         return new KoCopyColorConversionTransformation(srcColorSpace);
     }
     Q_ASSERT(srcColorSpace);
     Q_ASSERT(dstColorSpace);
     dbgPigmentCCS << srcColorSpace->id() << (srcColorSpace->profile() ? srcColorSpace->profile()->name() : "default");
     dbgPigmentCCS << dstColorSpace->id() << (dstColorSpace->profile() ? dstColorSpace->profile()->name() : "default");
     Path path = findBestPath(
                      nodeFor(srcColorSpace),
                      nodeFor(dstColorSpace));
     Q_ASSERT(path.length() > 0);
     KoColorConversionTransformation* transfo = createTransformationFromPath(path, srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
     Q_ASSERT(*transfo->srcColorSpace() == *srcColorSpace);
     Q_ASSERT(*transfo->dstColorSpace() == *dstColorSpace);
     Q_ASSERT(transfo);
     return transfo;
 }
 
 void KoColorConversionSystem::createColorConverters(const KoColorSpace* colorSpace, const QList< QPair<KoID, KoID> >& possibilities, KoColorConversionTransformation*& fromCS, KoColorConversionTransformation*& toCS) const
 {
     // TODO This function currently only select the best conversion only based on the transformation
     // from colorSpace to one of the color spaces in the list, but not the other way around
     // it might be worth to look also the return path.
     const Node* csNode = nodeFor(colorSpace);
     PathQualityChecker pQC(csNode->referenceDepth, !csNode->isHdr, !csNode->isGray);
     // Look for a color conversion
     Path bestPath;
     typedef QPair<KoID, KoID> KoID2KoID;
     Q_FOREACH (const KoID2KoID & possibility, possibilities) {
-        const KoColorSpaceFactory* csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(KoColorSpaceRegistry::instance()->colorSpaceId(possibility.first.id(), possibility.second.id()));
+        const KoColorSpaceFactory* csf = d->registryInterface->colorSpaceFactory(possibility.first.id(), possibility.second.id());
         if (csf) {
             Path path = findBestPath(csNode, nodeFor(csf->colorModelId().id(), csf->colorDepthId().id(), csf->defaultProfile()));
             Q_ASSERT(path.length() > 0);
             path.isGood = pQC.isGoodPath(path);
 
             if (bestPath.isEmpty()) {
                 bestPath = path;
             } else if ((!bestPath.isGood &&  path.isGood) || pQC.lessWorseThan(path, bestPath)) {
                 bestPath = path;
             }
         }
     }
     Q_ASSERT(!bestPath.isEmpty());
     const KoColorSpace* endColorSpace = defaultColorSpaceForNode(bestPath.endNode());
     fromCS = createTransformationFromPath(bestPath, colorSpace, endColorSpace, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     Path returnPath = findBestPath(bestPath.endNode(), csNode);
     Q_ASSERT(!returnPath.isEmpty());
     toCS = createTransformationFromPath(returnPath, endColorSpace, colorSpace, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     Q_ASSERT(*toCS->dstColorSpace() == *fromCS->srcColorSpace());
     Q_ASSERT(*fromCS->dstColorSpace() == *toCS->srcColorSpace());
 }
 
 KoColorConversionTransformation* KoColorConversionSystem::createTransformationFromPath(const Path &path, const KoColorSpace * srcColorSpace, const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     Q_ASSERT(srcColorSpace->colorModelId().id() == path.startNode()->modelId);
     Q_ASSERT(srcColorSpace->colorDepthId().id() == path.startNode()->depthId);
     Q_ASSERT(dstColorSpace->colorModelId().id() == path.endNode()->modelId);
     Q_ASSERT(dstColorSpace->colorDepthId().id() == path.endNode()->depthId);
 
     KoColorConversionTransformation* transfo;
 
     const QList< Path::node2factory > pathOfNode = path.compressedPath();
 
     if (pathOfNode.size() == 2) { // Direct connection
         transfo = pathOfNode[1].second->createColorTransformation(srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
     }
     else {
 
         KoMultipleColorConversionTransformation* mccTransfo = new KoMultipleColorConversionTransformation(srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
 
         transfo = mccTransfo;
 
         // Get the first intermediary color space
         dbgPigmentCCS << pathOfNode[ 0 ].first->id() << " to " << pathOfNode[ 1 ].first->id();
 
         const KoColorSpace* intermCS =
             defaultColorSpaceForNode(pathOfNode[1].first);
 
         mccTransfo->appendTransfo(pathOfNode[1].second->createColorTransformation(srcColorSpace, intermCS, renderingIntent, conversionFlags));
 
         for (int i = 2; i < pathOfNode.size() - 1; i++) {
             dbgPigmentCCS << pathOfNode[ i - 1 ].first->id() << " to " << pathOfNode[ i ].first->id();
             const KoColorSpace* intermCS2 = defaultColorSpaceForNode(pathOfNode[i].first);
             Q_ASSERT(intermCS2);
             mccTransfo->appendTransfo(pathOfNode[i].second->createColorTransformation(intermCS, intermCS2, renderingIntent, conversionFlags));
             intermCS = intermCS2;
         }
 
         dbgPigmentCCS << pathOfNode[ pathOfNode.size() - 2 ].first->id() << " to " << pathOfNode[ pathOfNode.size() - 1 ].first->id();
         mccTransfo->appendTransfo(pathOfNode.last().second->createColorTransformation(intermCS, dstColorSpace, renderingIntent, conversionFlags));
     }
     return transfo;
 }
 
 
 KoColorConversionSystem::Vertex* KoColorConversionSystem::vertexBetween(KoColorConversionSystem::Node* srcNode, KoColorConversionSystem::Node* dstNode)
 {
     Q_FOREACH (Vertex* oV, srcNode->outputVertexes) {
         if (oV->dstNode == dstNode) {
             return oV;
         }
     }
     return 0;
 }
 
 KoColorConversionSystem::Vertex* KoColorConversionSystem::createVertex(Node* srcNode, Node* dstNode)
 {
     Vertex* v = new Vertex(srcNode, dstNode);
     srcNode->outputVertexes.append(v);
     d->vertexes.append(v);
     return v;
 }
 
 // -- Graph visualization functions --
 
 QString KoColorConversionSystem::vertexToDot(KoColorConversionSystem::Vertex* v, const QString &options) const
 {
     return QString("  \"%1\" -> \"%2\" %3\n").arg(v->srcNode->id()).arg(v->dstNode->id()).arg(options);
 }
 
 QString KoColorConversionSystem::toDot() const
 {
     QString dot = "digraph CCS {\n";
     Q_FOREACH (Vertex* oV, d->vertexes) {
         dot += vertexToDot(oV, "default") ;
     }
     dot += "}\n";
     return dot;
 }
 
 bool KoColorConversionSystem::existsPath(const QString& srcModelId, const QString& srcDepthId, const QString& srcProfileName, const QString& dstModelId, const QString& dstDepthId, const QString& dstProfileName) const
 {
     dbgPigmentCCS << "srcModelId = " << srcModelId << " srcDepthId = " << srcDepthId << " srcProfileName = " << srcProfileName << " dstModelId = " << dstModelId << " dstDepthId = " << dstDepthId << " dstProfileName = " << dstProfileName;
     const Node* srcNode = nodeFor(srcModelId, srcDepthId, srcProfileName);
     const Node* dstNode = nodeFor(dstModelId, dstDepthId, dstProfileName);
     if (srcNode == dstNode) return true;
     if (!srcNode) return false;
     if (!dstNode) return false;
     Path path = findBestPath(srcNode, dstNode);
     bool exist = !path.isEmpty();
     return exist;
 }
 
 bool KoColorConversionSystem::existsGoodPath(const QString& srcModelId, const QString& srcDepthId, const QString& srcProfileName, const QString& dstModelId, const QString& dstDepthId, const QString& dstProfileName) const
 {
     const Node* srcNode = nodeFor(srcModelId, srcDepthId, srcProfileName);
     const Node* dstNode = nodeFor(dstModelId, dstDepthId, dstProfileName);
     if (srcNode == dstNode) return true;
     if (!srcNode) return false;
     if (!dstNode) return false;
     Path path = findBestPath(srcNode, dstNode);
     bool existAndGood = path.isGood;
     return existAndGood;
 }
 
 
 QString KoColorConversionSystem::bestPathToDot(const QString& srcKey, const QString& dstKey) const
 {
     const Node* srcNode = 0;
     const Node* dstNode = 0;
     Q_FOREACH (Node* node, d->graph) {
         if (node->id() == srcKey) {
             srcNode = node;
         }
         if (node->id() == dstKey) {
             dstNode = node;
         }
     }
     Path p = findBestPath(srcNode, dstNode);
     Q_ASSERT(!p.isEmpty());
     QString dot = "digraph CCS {\n" +
                   QString("  \"%1\" [color=red]\n").arg(srcNode->id()) +
                   QString("  \"%1\" [color=red]\n").arg(dstNode->id());
     Q_FOREACH (Vertex* oV, d->vertexes) {
         QString options;
         if (p.vertexes.contains(oV)) {
             options = "[color=red]";
         }
         dot += vertexToDot(oV, options) ;
     }
     dot += "}\n";
     return dot;
 }
 
 inline KoColorConversionSystem::Path KoColorConversionSystem::findBestPathImpl2(const KoColorConversionSystem::Node* srcNode, const KoColorConversionSystem::Node* dstNode, bool ignoreHdr, bool ignoreColorCorrectness) const
 {
     PathQualityChecker pQC(qMin(srcNode->referenceDepth, dstNode->referenceDepth), ignoreHdr, ignoreColorCorrectness);
     Node2PathHash node2path; // current best path to reach a given node
     QList<Path> possiblePaths; // list of all paths
     // Generate the initial list of paths
     Q_FOREACH (Vertex* v, srcNode->outputVertexes) {
         if (v->dstNode->isInitialized) {
             Path p;
             p.appendVertex(v);
             Node* endNode = v->dstNode;
             if (endNode == dstNode) {
                 Q_ASSERT(pQC.isGoodPath(p));  // <- it's a direct link, it has to be a good path
                 p.isGood = true;
                 return p;
             } else {
                 Q_ASSERT(!node2path.contains(endNode));   // That would be a total fuck up if there are two vertexes between two nodes
                 node2path.insert(endNode, p);
                 possiblePaths.append(p);
             }
         }
     }
 
     Path currentBestPath;
     // Continue while there are any possibilities remaining
     while (possiblePaths.size() > 0) {
 
         // Loop through all paths and explore one step further
         const QList<Path> currentPaths = possiblePaths;
         for (const Path &p : currentPaths) {
             const Node* endNode = p.endNode();
             for (Vertex* v : endNode->outputVertexes) {
                 if (v->dstNode->isInitialized && !p.contains(v->dstNode)) {
                     Path newP = p;  // Candidate
                     newP.appendVertex(v);
                     Node* newEndNode = v->dstNode;
                     if (newEndNode == dstNode) {
                         if (pQC.isGoodPath(newP)) { // Victory
                             newP.isGood = true;
                             return newP;
                         } else if (pQC.lessWorseThan(newP, currentBestPath)) {
                             Q_ASSERT(newP.startNode()->id() == currentBestPath.startNode()->id());
                             Q_ASSERT(newP.endNode()->id() == currentBestPath.endNode()->id());
                             // Can we do better than dumping memory values???
                             // warnPigment << pQC.lessWorseThan(newP, currentBestPath) << " " << newP << "  " << currentBestPath;
                             currentBestPath = newP;
                         }
                     } else {
                         // This is an incomplete path. Check if there's a better way to get to its endpoint.
                         Node2PathHash::Iterator it = node2path.find(newEndNode);
                         if (it != node2path.end()) {
                             Path &p2 = it.value();
                             if (pQC.lessWorseThan(newP, p2)) {
                                 p2 = newP;
                                 possiblePaths.append(newP);
                             }
                         } else {
                             node2path.insert(newEndNode, newP);
                             possiblePaths.append(newP);
                         }
                     }
                 }
             }
             possiblePaths.removeAll(p); // Remove from list of remaining paths
         }
     }
     if (!currentBestPath.isEmpty()) {
         warnPigment << "No good path from " << srcNode->id() << " to " << dstNode->id() << " found : length = " << currentBestPath.length() << " cost = " << currentBestPath.cost << " referenceDepth = " << currentBestPath.referenceDepth << " respectColorCorrectness = " << currentBestPath.respectColorCorrectness << " isGood = " << currentBestPath.isGood ;
         return currentBestPath;
     }
     errorPigment << "No path from " << srcNode->id() << " to " << dstNode->id() << " found not ";
     return currentBestPath;
 }
 
 inline KoColorConversionSystem::Path KoColorConversionSystem::findBestPathImpl(const KoColorConversionSystem::Node* srcNode, const KoColorConversionSystem::Node* dstNode, bool ignoreHdr) const
 {
     Q_ASSERT(srcNode);
     Q_ASSERT(dstNode);
     return findBestPathImpl2(srcNode, dstNode, ignoreHdr, (srcNode->isGray || dstNode->isGray));
 }
 
 KoColorConversionSystem::Path KoColorConversionSystem::findBestPath(const KoColorConversionSystem::Node* srcNode, const KoColorConversionSystem::Node* dstNode) const
 {
     Q_ASSERT(srcNode);
     Q_ASSERT(dstNode);
     dbgPigmentCCS << "Find best path between " << srcNode->id() << " and  " << dstNode->id();
     if (srcNode->isHdr &&  dstNode->isHdr) {
         return findBestPathImpl(srcNode, dstNode, false);
     } else {
         return findBestPathImpl(srcNode, dstNode, true);
     }
 }
diff --git a/libs/pigment/KoColorConversionSystem.h b/libs/pigment/KoColorConversionSystem.h
index 086d6795b9..49b39b9889 100644
--- a/libs/pigment/KoColorConversionSystem.h
+++ b/libs/pigment/KoColorConversionSystem.h
@@ -1,180 +1,190 @@
 /*
  *  Copyright (c) 2007-2008 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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.
 */
 
 #ifndef _KO_COLOR_CONVERSION_SYSTEM_H_
 #define _KO_COLOR_CONVERSION_SYSTEM_H_
 
 class KoColorProfile;
 class KoColorSpace;
 class KoColorSpaceFactory;
 class KoColorSpaceEngine;
 class KoID;
 
 #include "KoColorConversionTransformation.h"
 
 #include <QList>
 #include <QPair>
 
 #include "kritapigment_export.h"
 
 /**
  * This class hold the logic related to pigment's Color Conversion System. It's
  * basically a graph containing all the possible color transformation between
  * the color spaces. The most useful functions are createColorConverter to create
  * a color conversion between two color spaces, and insertColorSpace which is called
  * by KoColorSpaceRegistry each time a new color space is added to the registry.
  *
  * This class is not part of public API, and can be changed without notice.
  */
 class KRITAPIGMENT_EXPORT KoColorConversionSystem
 {
+public:
+    struct RegistryInterface {
+        virtual ~RegistryInterface() {}
+
+        virtual const KoColorSpace * colorSpace(const QString & colorModelId, const QString & colorDepthId, const QString &profileName) = 0;
+        virtual const KoColorSpaceFactory* colorSpaceFactory(const QString &colorModelId, const QString &colorDepthId) const = 0;
+        virtual QList<const KoColorProfile *>  profilesFor(const KoColorSpaceFactory * csf) const = 0;
+        virtual QList<const KoColorSpaceFactory*> colorSpacesFor(const KoColorProfile* profile) const = 0;
+    };
+
 public:
     struct Node;
     struct Vertex;
     struct NodeKey;
     friend uint qHash(const KoColorConversionSystem::NodeKey &key);
     struct Path;
     /**
      * Construct a Color Conversion System, leave to the KoColorSpaceRegistry to
      * create it.
      */
-    KoColorConversionSystem();
+    KoColorConversionSystem(RegistryInterface *registryInterface);
     ~KoColorConversionSystem();
     /**
      * This function is called by the KoColorSpaceRegistry to add a new color space
      * to the graph of transformation.
      */
     void insertColorSpace(const KoColorSpaceFactory*);
 
     void insertColorProfile(const KoColorProfile*);
     /**
      * This function is called by the color space to create a color conversion
      * between two color space. This function search in the graph of transformations
      * the best possible path between the two color space.
      */
     KoColorConversionTransformation* createColorConverter(const KoColorSpace * srcColorSpace, const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const;
 
     /**
      * This function creates two transformations, one from the color space and one to the
      * color space. The destination color space is picked from a list of color space, such
      * as the conversion between the two color space is of the best quality.
      *
      * The typical use case of this function is for KoColorTransformationFactory which
      * doesn't support all color spaces, so unsupported color space have to find an
      * acceptable conversion in order to use that KoColorTransformationFactory.
      *
      * @param colorSpace the source color space
      * @param possibilities a list of color space among which we need to find the best
      *                      conversion
      * @param fromCS the conversion from the source color space will be affected to this
      *               variable
      * @param toCS the revert conversion to the source color space will be affected to this
      *             variable
      */
     void createColorConverters(const KoColorSpace* colorSpace, const QList< QPair<KoID, KoID> >& possibilities, KoColorConversionTransformation*& fromCS, KoColorConversionTransformation*& toCS) const;
 public:
     /**
      * This function return a text that can be compiled using dot to display
      * the graph of color conversion connection.
      */
     QString toDot() const;
     /**
      * This function return a text that can be compiled using dot to display
      * the graph of color conversion connection, with a red link to show the
      * path of the best color conversion.
      */
     QString bestPathToDot(const QString& srcKey, const QString& dstKey) const;
 public:
     /**
      * @return true if there is a path between two color spaces
      */
     bool existsPath(const QString& srcModelId, const QString& srcDepthId, const QString& srcProfileName, const QString& dstModelId, const QString& dstDepthId, const QString& dstProfileName) const;
     /**
      * @return true if there is a good path between two color spaces
      */
     bool existsGoodPath(const QString& srcModelId, const QString& srcDepthId, const QString& srcProfileName, const QString& dstModelId, const QString& dstDepthId, const QString& dstProfileName) const;
 private:
     QString vertexToDot(Vertex* v, const QString &options) const;
 private:
     /**
      * Insert an engine.
      */
     Node* insertEngine(const KoColorSpaceEngine* engine);
     KoColorConversionTransformation* createTransformationFromPath(const KoColorConversionSystem::Path& path, const KoColorSpace* srcColorSpace, const KoColorSpace* dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const;
     /**
      * Query the registry to get the color space associated with this
      * node. (default profile)
      */
     const KoColorSpace* defaultColorSpaceForNode(const Node* node) const;
     /**
      * Create a new node
      */
     Node* createNode(const QString& _modelId, const QString& _depthId, const QString& _profileName);
     /**
      * Initialise a node for ICC color spaces
      */
     void connectToEngine(Node* _node, Node* _engine);
     const Node* nodeFor(const KoColorSpace*) const;
     /**
      * @return the node corresponding to that key, or create it if needed
      */
     Node* nodeFor(const NodeKey& key);
     const Node* nodeFor(const NodeKey& key) const;
     /**
      * @return the list of nodes that correspond to a given model and depth.
      */
     QList<Node*> nodesFor(const QString& _modelId, const QString& _depthId);
     /**
      * @return the node associated with that key, and create it if needed
      */
     Node* nodeFor(const QString& colorModelId, const QString& colorDepthId, const QString& _profileName);
     const Node* nodeFor(const QString& colorModelId, const QString& colorDepthId, const QString& _profileName) const;
     /**
      * @return the vertex between two nodes, or null if the vertex doesn't exist
      */
     Vertex* vertexBetween(Node* srcNode, Node* dstNode);
     /**
      * create a vertex between two nodes and return it.
      */
     Vertex* createVertex(Node* srcNode, Node* dstNode);
     /**
      * looks for the best path between two nodes
      */
     Path findBestPath(const Node* srcNode, const Node* dstNode) const;
     /**
      * Delete all the paths of the list given in argument.
      */
     void deletePaths(QList<KoColorConversionSystem::Path*> paths) const;
     /**
      * Don't call that function, but raher findBestPath
      * @internal
      */
     inline Path findBestPathImpl2(const Node* srcNode, const Node* dstNode, bool ignoreHdr, bool ignoreColorCorrectness) const;
     /**
      * Don't call that function, but raher findBestPath
      * @internal
      */
     inline Path findBestPathImpl(const Node* srcNode, const Node* dstNode, bool ignoreHdr) const;
 
 private:
     struct Private;
     Private* const d;
 };
 
 #endif
diff --git a/libs/pigment/KoColorConversionSystem_p.h b/libs/pigment/KoColorConversionSystem_p.h
index e6536bf18a..5d21f930a7 100644
--- a/libs/pigment/KoColorConversionSystem_p.h
+++ b/libs/pigment/KoColorConversionSystem_p.h
@@ -1,324 +1,327 @@
 /*
  *  Copyright (c) 2007-2008 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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.
 */
 
 #ifndef KOCOLORCONVERSIONSYSTEM_P_H
 #define KOCOLORCONVERSIONSYSTEM_P_H
 
 #include "DebugPigment.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorModelStandardIds.h"
 #include "KoColorConversionTransformationFactory.h"
 #include "KoColorSpaceEngine.h"
 
 #include <QList>
 
 struct KoColorConversionSystem::Node {
 
     Node()
         : isHdr(false)
         , isInitialized(false)
         , referenceDepth(0)
         , isGray(false)
         , crossingCost(1)
         , colorSpaceFactory(0)
         , isEngine(false)
         , engine(0) {}
 
     void init(const KoColorSpaceFactory* _colorSpaceFactory) {
         dbgPigment << "Initialise " << modelId << " " << depthId << " " << profileName;
 
         if (isInitialized) {
             dbgPigment << "Re-initializing node. Old factory" << colorSpaceFactory << "new factory" << _colorSpaceFactory;
         }
         isInitialized = true;
 
         if (_colorSpaceFactory) {
             isHdr = _colorSpaceFactory->isHdr();
             colorSpaceFactory = _colorSpaceFactory;
             referenceDepth = _colorSpaceFactory->referenceDepth();
             isGray = (_colorSpaceFactory->colorModelId() == GrayAColorModelID
                       || _colorSpaceFactory->colorModelId() == GrayColorModelID
                       || _colorSpaceFactory->colorModelId() == AlphaColorModelID);
         }
     }
 
     void init(const KoColorSpaceEngine* _engine) {
         Q_ASSERT(!isInitialized);
         isEngine = true;
         isInitialized = true;
         isHdr = true;
         engine = _engine;
     }
 
     QString id() const {
         return modelId + " " + depthId + " " + profileName;
     }
 
     QString modelId;
     QString depthId;
     QString profileName;
     bool isHdr;
     bool isInitialized;
     int referenceDepth;
     QList<Vertex*> outputVertexes;
     bool isGray;
     int crossingCost;
     const KoColorSpaceFactory* colorSpaceFactory;
     bool isEngine;
     const KoColorSpaceEngine* engine;
 };
 Q_DECLARE_TYPEINFO(KoColorConversionSystem::Node, Q_MOVABLE_TYPE);
 
 struct KoColorConversionSystem::Vertex {
 
     Vertex(Node* _srcNode, Node* _dstNode)
         : srcNode(_srcNode)
         , dstNode(_dstNode)
         , factoryFromSrc(0)
         , factoryFromDst(0) {
     }
 
     ~Vertex() {
         if (factoryFromSrc == factoryFromDst) {
             delete factoryFromSrc;
         } else {
             delete factoryFromSrc;
             delete factoryFromDst;
         }
     }
 
     void setFactoryFromSrc(KoColorConversionTransformationFactory* factory) {
         factoryFromSrc = factory;
         initParameter(factoryFromSrc);
     }
 
     void setFactoryFromDst(KoColorConversionTransformationFactory* factory) {
         factoryFromDst = factory;
         if (!factoryFromSrc) initParameter(factoryFromDst);
     }
 
     void initParameter(KoColorConversionTransformationFactory* transfo) {
         conserveColorInformation = transfo->conserveColorInformation();
         conserveDynamicRange = transfo->conserveDynamicRange();
     }
 
     KoColorConversionTransformationFactory* factory() {
         if (factoryFromSrc) return factoryFromSrc;
         return factoryFromDst;
     }
 
     Node* srcNode;
     Node* dstNode;
 
     bool conserveColorInformation;
     bool conserveDynamicRange;
 
 private:
 
     KoColorConversionTransformationFactory* factoryFromSrc; // Factory provided by the destination node
     KoColorConversionTransformationFactory* factoryFromDst; // Factory provided by the destination node
 
 };
 
 struct KoColorConversionSystem::NodeKey {
 
     NodeKey(const QString &_modelId, const QString &_depthId, const QString &_profileName)
         : modelId(_modelId)
         , depthId(_depthId)
         , profileName(_profileName) {}
 
     bool operator==(const KoColorConversionSystem::NodeKey& rhs) const {
         return modelId == rhs.modelId && depthId == rhs.depthId && profileName == rhs.profileName;
     }
 
     QString modelId;
     QString depthId;
     QString profileName;
 };
 Q_DECLARE_TYPEINFO(KoColorConversionSystem::NodeKey, Q_MOVABLE_TYPE);
 
 struct KoColorConversionSystem::Path {
 
     Path()
         : respectColorCorrectness(true)
         , referenceDepth(0)
         , keepDynamicRange(true)
         , isGood(false)
         , cost(0) {}
 
     Node* startNode() {
         return (vertexes.first())->srcNode;
     }
 
     bool operator==(const Path &other) const {
       return other.vertexes == vertexes;
     }
 
 
     const Node* startNode() const {
         return (vertexes.first())->srcNode;
     }
 
     Node* endNode() {
         return (vertexes.last())->dstNode;
     }
 
     const Node* endNode() const {
         return (vertexes.last())->dstNode;
     }
 
     bool isEmpty() const {
         return vertexes.isEmpty();
     }
 
     void appendVertex(Vertex* v) {
         if (vertexes.empty()) {
             referenceDepth = v->srcNode->referenceDepth;
         }
         vertexes.append(v);
         if (!v->conserveColorInformation) respectColorCorrectness = false;
         if (!v->conserveDynamicRange) keepDynamicRange = false;
         referenceDepth = qMin(referenceDepth, v->dstNode->referenceDepth);
         cost += v->dstNode->crossingCost;
     }
 
     // Compress path to hide the Engine node and correctly select the factory
     typedef QPair<Node*, const KoColorConversionTransformationAbstractFactory* > node2factory;
     QList< node2factory > compressedPath() const {
         QList< node2factory > nodes;
         nodes.push_back(node2factory(vertexes.first()->srcNode , vertexes.first()->factory()));
         const KoColorConversionTransformationAbstractFactory* previousFactory = 0;
         Q_FOREACH (Vertex* vertex, vertexes) { // Unless the node is the icc node, add it to the path
             Node* n = vertex->dstNode;
             if (n->isEngine) {
                 previousFactory = n->engine;
             } else {
                 nodes.push_back(
                             node2factory(n,
                                          previousFactory ? previousFactory : vertex->factory()));
                 previousFactory = 0;
             }
         }
         return nodes;
     }
 
     int length() const {
         return vertexes.size();
     }
 
     bool contains(Node* n) const {
         Q_FOREACH (Vertex* v, vertexes) {
             if (v->srcNode == n || v->dstNode == n) {
                 return true;
             }
         }
         return false;
     }
 
     QList<Vertex*> vertexes;
     bool respectColorCorrectness;
     int referenceDepth;
     bool keepDynamicRange;
     bool isGood;
     int cost;
 };
 Q_DECLARE_TYPEINFO(KoColorConversionSystem::Path, Q_MOVABLE_TYPE);
 
 
 inline QDebug operator<<(QDebug dbg, const KoColorConversionSystem::Path &path)
 {
     bool havePrintedFirst = false;
 
     Q_FOREACH (const KoColorConversionSystem::Vertex *v, path.vertexes) {
         if (!havePrintedFirst) {
             dbg.nospace() << v->srcNode->id();
             havePrintedFirst = true;
         }
 
         dbg.nospace() << "->" << v->dstNode->id();
     }
 
     return dbg.space();
 }
 
 
 typedef QHash<KoColorConversionSystem::Node*, KoColorConversionSystem::Path > Node2PathHash;
 
 
 uint qHash(const KoColorConversionSystem::NodeKey &key)
 {
     return qHash(key.modelId) + qHash(key.depthId);
 }
 
 struct Q_DECL_HIDDEN KoColorConversionSystem::Private {
 
+    Private(RegistryInterface *_registryInterface) : registryInterface(_registryInterface) {}
+
     QHash<NodeKey, Node*> graph;
     QList<Vertex*> vertexes;
+    RegistryInterface *registryInterface;
 };
 
 #define CHECK_ONE_AND_NOT_THE_OTHER(name) \
     if(path1. name && !path2. name) \
 { \
     return true; \
     } \
     if(!path1. name && path2. name) \
 { \
     return false; \
     }
 
 struct PathQualityChecker {
 
     PathQualityChecker(int _referenceDepth, bool _ignoreHdr, bool _ignoreColorCorrectness)
         : referenceDepth(_referenceDepth)
         , ignoreHdr(_ignoreHdr)
         , ignoreColorCorrectness(_ignoreColorCorrectness)
     {}
 
     /// @return true if the path maximize all the criterions (except length)
     inline bool isGoodPath(const KoColorConversionSystem::Path & path) const {
 
         return (path.respectColorCorrectness || ignoreColorCorrectness) &&
                 (path.referenceDepth >= referenceDepth) &&
                 (path.keepDynamicRange || ignoreHdr);
     }
 
     /**
      * Compare two paths.
      */
     inline bool lessWorseThan(const KoColorConversionSystem::Path &path1, const KoColorConversionSystem::Path &path2) const {
         // There is no point in comparing two paths which doesn't start from the same node or doesn't end at the same node
         if (!ignoreHdr) {
             CHECK_ONE_AND_NOT_THE_OTHER(keepDynamicRange)
         }
         if (!ignoreColorCorrectness) {
             CHECK_ONE_AND_NOT_THE_OTHER(respectColorCorrectness)
         }
         if (path1.referenceDepth == path2.referenceDepth) {
             return path1.cost < path2.cost; // if they have the same cost, well anyway you have to choose one, and there is no point in keeping one and not the other
         }
         return path1.referenceDepth > path2.referenceDepth;
     }
     int referenceDepth;
     bool ignoreHdr;
     bool ignoreColorCorrectness;
 };
 
 #undef CHECK_ONE_AND_NOT_THE_OTHER
 
 #endif
diff --git a/libs/pigment/KoColorProfileStorage.cpp b/libs/pigment/KoColorProfileStorage.cpp
new file mode 100644
index 0000000000..0f91923e63
--- /dev/null
+++ b/libs/pigment/KoColorProfileStorage.cpp
@@ -0,0 +1,148 @@
+/*
+ *  Copyright (c) 2017 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 "KoColorProfileStorage.h"
+
+#include <QHash>
+#include <QReadWriteLock>
+#include <QString>
+
+#include "KoColorSpaceFactory.h"
+#include "KoColorProfile.h"
+#include "kis_assert.h"
+
+
+struct KoColorProfileStorage::Private {
+    QHash<QString, KoColorProfile * > profileMap;
+    QHash<QByteArray, KoColorProfile * > profileUniqueIdMap;
+    QHash<QString, QString> profileAlias;
+    QReadWriteLock lock;
+
+    void populateUniqueIdMap();
+};
+
+KoColorProfileStorage::KoColorProfileStorage()
+    : d(new Private)
+{
+
+}
+
+KoColorProfileStorage::~KoColorProfileStorage()
+{
+}
+
+void KoColorProfileStorage::addProfile(KoColorProfile *profile)
+{
+    QWriteLocker locker(&d->lock);
+
+    if (profile->valid()) {
+        d->profileMap[profile->name()] = profile;
+        if (!d->profileUniqueIdMap.isEmpty()) {
+            d->profileUniqueIdMap.insert(profile->uniqueId(), profile);
+        }
+    }
+}
+
+void KoColorProfileStorage::addProfile(const KoColorProfile *profile)
+{
+    addProfile(profile->clone());
+}
+
+void KoColorProfileStorage::removeProfile(KoColorProfile *profile)
+{
+    QWriteLocker locker(&d->lock);
+
+    d->profileMap.remove(profile->name());
+    if (!d->profileUniqueIdMap.isEmpty()) {
+        d->profileUniqueIdMap.remove(profile->uniqueId());
+    }
+}
+
+bool KoColorProfileStorage::containsProfile(const KoColorProfile *profile)
+{
+    QReadLocker l(&d->lock);
+    return d->profileMap.contains(profile->name());
+}
+
+void KoColorProfileStorage::addProfileAlias(const QString &name, const QString &to)
+{
+    QWriteLocker l(&d->lock);
+    d->profileAlias[name] = to;
+}
+
+QString KoColorProfileStorage::profileAlias(const QString &name) const
+{
+    QReadLocker l(&d->lock);
+    return d->profileAlias.value(name, name);
+}
+
+const KoColorProfile *KoColorProfileStorage::profileByName(const QString &name) const
+{
+    QReadLocker l(&d->lock);
+    return d->profileMap.value(d->profileAlias.value(name, name), 0);
+}
+
+void KoColorProfileStorage::Private::populateUniqueIdMap()
+{
+    QWriteLocker l(&lock);
+    profileUniqueIdMap.clear();
+
+    for (auto it = profileMap.constBegin();
+         it != profileMap.constEnd();
+         ++it) {
+
+        KoColorProfile *profile = it.value();
+        QByteArray id = profile->uniqueId();
+
+        if (!id.isEmpty()) {
+            profileUniqueIdMap.insert(id, profile);
+        }
+    }
+}
+
+
+const KoColorProfile *KoColorProfileStorage::profileByUniqueId(const QByteArray &id) const
+{
+    QReadLocker l(&d->lock);
+    if (d->profileUniqueIdMap.isEmpty()) {
+        l.unlock();
+        d->populateUniqueIdMap();
+        l.relock();
+    }
+    return d->profileUniqueIdMap.value(id, 0);
+
+}
+
+QList<const KoColorProfile *> KoColorProfileStorage::profilesFor(const KoColorSpaceFactory *csf) const
+{
+    QList<const KoColorProfile *>  profiles;
+    if (!csf) return profiles;
+
+    QReadLocker l(&d->lock);
+
+    QHash<QString, KoColorProfile * >::ConstIterator it;
+    for (it = d->profileMap.constBegin(); it != d->profileMap.constEnd(); ++it) {
+        KoColorProfile *  profile = it.value();
+        if (csf->profileIsCompatible(profile)) {
+            Q_ASSERT(profile);
+            //         if (profile->colorSpaceSignature() == csf->colorSpaceSignature()) {
+            profiles.push_back(profile);
+        }
+    }
+    return profiles;
+}
diff --git a/libs/pigment/KoColorProfileStorage.h b/libs/pigment/KoColorProfileStorage.h
new file mode 100644
index 0000000000..1216447250
--- /dev/null
+++ b/libs/pigment/KoColorProfileStorage.h
@@ -0,0 +1,91 @@
+/*
+ *  Copyright (c) 2017 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.
+ */
+
+#ifndef KOCOLORPROFILESTORAGE_H
+#define KOCOLORPROFILESTORAGE_H
+
+#include <QScopedPointer>
+
+class QByteArray;
+class QString;
+class KoColorProfile;
+class KoColorSpaceFactory;
+
+class KoColorProfileStorage
+{
+public:
+    KoColorProfileStorage();
+    ~KoColorProfileStorage();
+
+    /**
+     * Register the profile in the storage
+     * @param profile the new profile to be registered
+     */
+    void addProfile(KoColorProfile* profile);
+    void addProfile(const KoColorProfile* profile); // TODO
+
+    void removeProfile(KoColorProfile* profile);
+
+    bool containsProfile(const KoColorProfile *profile);
+
+    /**
+     * Create an alias to a profile with a different name. Then @ref profileByName
+     * will return the profile @p to when passed @p name as a parameter.
+     */
+    void addProfileAlias(const QString& name, const QString& to);
+
+    /**
+     * @return the profile alias, or name if not aliased
+     */
+    QString profileAlias(const QString& name) const;
+
+    /**
+     * Return a profile by its given name, or 0 if none registered.
+     * @return a profile by its given name, or 0 if none registered.
+     * @param name the product name as set on the profile.
+     * @see addProfile()
+     * @see KoColorProfile::productName()
+     */
+    const KoColorProfile * profileByName(const QString & name) const ;
+
+
+    /**
+     * Returns a profile by its unique id stored/calculated in the header.
+     * The first call to this function might take long, because the map is
+     * created on the first use only (atm used by SVG only)
+     * @param id unique ProfileID of the profile (MD5 sum of its header)
+     * @return the profile or 0 if not found
+     */
+    const KoColorProfile *profileByUniqueId(const QByteArray &id) const;
+
+    /**
+     * Return the list of profiles for a colorspace represented by its factory.
+     * Profiles will not work with any color space, you can query which profiles
+     * that are registered with this registry can be used in combination with the
+     * argument factory.
+     * @param csf is a factory for the requested color space
+     * @return a list of profiles for the factory
+     */
+    QList<const KoColorProfile *>  profilesFor(const KoColorSpaceFactory * csf) const;
+
+private:
+    struct Private;
+    const QScopedPointer<Private> d;
+};
+
+#endif // KOCOLORPROFILESTORAGE_H
diff --git a/libs/pigment/KoColorSpace.cpp b/libs/pigment/KoColorSpace.cpp
index 634bbdb533..bb9cdb8ce6 100644
--- a/libs/pigment/KoColorSpace.cpp
+++ b/libs/pigment/KoColorSpace.cpp
@@ -1,821 +1,819 @@
 /*
  *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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 "KoColorSpace.h"
 #include "KoColorSpace_p.h"
 
 #include "KoChannelInfo.h"
 #include "DebugPigment.h"
 #include "KoCompositeOp.h"
 #include "KoColorTransformation.h"
 #include "KoColorTransformationFactory.h"
 #include "KoColorTransformationFactoryRegistry.h"
 #include "KoColorConversionCache.h"
 #include "KoColorConversionSystem.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorProfile.h"
 #include "KoCopyColorConversionTransformation.h"
 #include "KoFallBackColorTransformation.h"
 #include "KoUniqueNumberForIdServer.h"
 #include "KoMixColorsOp.h"
 #include "KoConvolutionOp.h"
 #include "KoCompositeOpRegistry.h"
 #include "KoColorSpaceEngine.h"
 
 #include <QThreadStorage>
 #include <QByteArray>
 #include <QBitArray>
 #include <QPolygonF>
 #include <QPointF>
 
 #include <math.h>
 
 KoColorSpace::KoColorSpace()
         : d(new Private())
 {
 }
 
 KoColorSpace::KoColorSpace(const QString &id, const QString &name, KoMixColorsOp* mixColorsOp, KoConvolutionOp* convolutionOp)
         : d(new Private())
 {
     d->id = id;
     d->idNumber = KoUniqueNumberForIdServer::instance()->numberForId(d->id);
     d->name = name;
     d->mixColorsOp = mixColorsOp;
     d->convolutionOp = convolutionOp;
     d->transfoToRGBA16 = 0;
     d->transfoFromRGBA16 = 0;
     d->transfoToLABA16 = 0;
     d->transfoFromLABA16 = 0;
     d->gamutXYY = QPolygonF();
     d->TRCXYY = QPolygonF();
     d->colorants = QVector <qreal> (0);
     d->lumaCoefficients = QVector <qreal> (0);
     d->iccEngine = 0;
     d->deletability = NotOwnedByRegistry;
 }
 
 KoColorSpace::~KoColorSpace()
 {
     Q_ASSERT(d->deletability != OwnedByRegistryDoNotDelete);
 
     qDeleteAll(d->compositeOps);
     Q_FOREACH (KoChannelInfo * channel, d->channels) {
         delete channel;
     }
     if (d->deletability == NotOwnedByRegistry) {
         KoColorConversionCache* cache = KoColorSpaceRegistry::instance()->colorConversionCache();
         if (cache) {
             cache->colorSpaceIsDestroyed(this);
         }
     }
     delete d->mixColorsOp;
     delete d->convolutionOp;
     delete d->transfoToRGBA16;
     delete d->transfoFromRGBA16;
     delete d->transfoToLABA16;
     delete d->transfoFromLABA16;
     delete d;
 }
 
 bool KoColorSpace::operator==(const KoColorSpace& rhs) const
 {
     const KoColorProfile* p1 = rhs.profile();
     const KoColorProfile* p2 = profile();
     return d->idNumber == rhs.d->idNumber && ((p1 == p2) || (*p1 == *p2));
 }
 
 QString KoColorSpace::id() const
 {
     return d->id;
 }
 
 QString KoColorSpace::name() const
 {
     return d->name;
 }
 
 //Color space info stuff.
 QPolygonF KoColorSpace::gamutXYY() const
 {
     if (d->gamutXYY.empty()) {
         //now, let's decide on the boundary. This is a bit tricky because icc profiles can be both matrix-shaper and cLUT at once if the maker so pleases.
         //first make a list of colors.
         qreal max = 1.0;
         if ((colorModelId().id()=="CMYKA" || colorModelId().id()=="LABA") && colorDepthId().id()=="F32") {
             //boundaries for cmyka/laba have trouble getting the max values for Float, and are pretty awkward in general.
             max = this->channels()[0]->getUIMax();
 
         }
         int samples = 5;//amount of samples in our color space.
-        QString name = KoColorSpaceRegistry::instance()->colorSpaceFactory("XYZAF32")->defaultProfile();
-        const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "F32", name);
+        const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "F32");
         quint8 *data = new quint8[pixelSize()];
         quint8 data2[16]; // xyza f32 is 4 floats, that is 16 bytes per pixel.
         //QVector <qreal> sampleCoordinates(pow(colorChannelCount(),samples));
         //sampleCoordinates.fill(0.0);
 
         // This is fixed to 5 since the maximum number of channels are 5 for CMYKA
         QVector <float> channelValuesF(5);//for getting the coordinates.
 
         for(int x=0;x<samples;x++){
             if (colorChannelCount()==1) {//gray
                 channelValuesF[0]=(max/(samples-1))*(x);
                 channelValuesF[1]=max;
                 fromNormalisedChannelsValue(data, channelValuesF);
                 convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric, KoColorConversionTransformation::adjustmentConversionFlags());
                 xyzColorSpace->normalisedChannelsValue(data2, channelValuesF);
                 qreal x = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                 qreal y = channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                 d->gamutXYY << QPointF(x,y);
             } else {
                 for(int y=0;y<samples;y++){
                     for(int z=0;z<samples;z++){
                         if (colorChannelCount()==4) {
                             for(int k=0;k<samples;k++){
                                 channelValuesF[0] = (max / (samples - 1)) * (x);
                                 channelValuesF[1] = (max / (samples - 1)) * (y);
                                 channelValuesF[2] = (max / (samples - 1)) * (z);
                                 channelValuesF[3] = (max / (samples - 1)) * (k);
                                 channelValuesF[4] = max;
                                 fromNormalisedChannelsValue(data, channelValuesF);
                                 convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric, KoColorConversionTransformation::adjustmentConversionFlags());
                                 xyzColorSpace->normalisedChannelsValue(data2, channelValuesF);
                                 qreal x = channelValuesF[0] / (channelValuesF[0] + channelValuesF[1] + channelValuesF[2]);
                                 qreal y = channelValuesF[1] / (channelValuesF[0] + channelValuesF[1] + channelValuesF[2]);
                                 d->gamutXYY<< QPointF(x,y);
                             }
                         } else {
                             channelValuesF[0]=(max/(samples-1))*(x);
                             channelValuesF[1]=(max/(samples-1))*(y);
                             channelValuesF[2]=(max/(samples-1))*(z);
                             channelValuesF[3]=max;
                             if (colorModelId().id()!="XYZA") { //no need for conversion when using xyz.
                                 fromNormalisedChannelsValue(data, channelValuesF);
                                 convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
                                 xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
                             }
                             qreal x = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             qreal y = channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->gamutXYY<< QPointF(x,y);
                         }
                     }
                 }
 
             }
         }
         delete[] data;
         //if we ever implement a boundary-checking thing I'd add it here.
         return d->gamutXYY;
     } else {
         return d->gamutXYY;
     }
 }
 
 QPolygonF KoColorSpace::estimatedTRCXYY() const
 {
     if (d->TRCXYY.empty()){
         qreal max = 1.0;
         if ((colorModelId().id()=="CMYKA" || colorModelId().id()=="LABA") && colorDepthId().id()=="F32") {
             //boundaries for cmyka/laba have trouble getting the max values for Float, and are pretty awkward in general.
             max = this->channels()[0]->getUIMax();
         }
-        QString name = KoColorSpaceRegistry::instance()->colorSpaceFactory("XYZAF16")->defaultProfile();
-        const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "F16", name);
+        const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "F16");
         quint8 *data = new quint8[pixelSize()];
         quint8 data2[8]; // xyza is 8 bytes per pixel.
 
         // This is fixed to 5 since the maximum number of channels are 5 for CMYKA
         QVector <float> channelValuesF(5);//for getting the coordinates.
 
         for (quint32 i=0; i<colorChannelCount(); i++) {
             qreal colorantY=1.0;
             if (colorModelId().id()!="CMYKA") {
                 for (int j=5; j>0; j--){
                     channelValuesF.fill(0.0);
                     channelValuesF[i] = ((max/4)*(5-j));
 
                     if (colorModelId().id()!="XYZA") { //no need for conversion when using xyz.
                         fromNormalisedChannelsValue(data, channelValuesF);
                         convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
                         xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
                     }
 
                     if (j==0) {
                         colorantY = channelValuesF[1];
                         if (d->colorants.size()<2){
                             d->colorants.resize(3*colorChannelCount());
                             d->colorants[i]  = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+1]= channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+2]= channelValuesF[1];
                         }
                     }
                     d->TRCXYY << QPointF(channelValuesF[1]/colorantY, ((1.0/4)*(5-j)));
                 }
             } else {
                 for (int j=0; j<5; j++){
                     channelValuesF.fill(0.0);
                     channelValuesF[i] = ((max/4)*(j));
 
                     fromNormalisedChannelsValue(data, channelValuesF);
 
                     convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
 
                     xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
 
                     if (j==0) {
                         colorantY = channelValuesF[1];
                         if (d->colorants.size()<2){
                             d->colorants.resize(3*colorChannelCount());
                             d->colorants[i]  = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+1]= channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+2]= channelValuesF[1];
                         }
                     }
                     d->TRCXYY << QPointF(channelValuesF[1]/colorantY, ((1.0/4)*(j)));
                 }
             }
         }
 
         delete[] data;
         return d->TRCXYY;
     } else {
         return d->TRCXYY;
     }
 }
 
 QVector <qreal> KoColorSpace::colorants() const
 {
     if (d->colorants.size()>1){
         return d->colorants;
     } else if (profile() && profile()->hasColorants()) {
         d->colorants.resize(3*colorChannelCount());
         d->colorants = profile()->getColorantsxyY();
         return d->colorants;
     } else {
         estimatedTRCXYY();
         return d->colorants;
     }
 }
 QVector <qreal> KoColorSpace::lumaCoefficients() const
 {
     if (d->lumaCoefficients.size()>1){
         return d->lumaCoefficients;
     } else {
         d->lumaCoefficients.resize(3);
         if (colorModelId().id()!="RGBA") {
             d->lumaCoefficients.fill(0.33);
         } else {
             colorants();
             if (d->colorants[2]<0 || d->colorants[5]<0 || d->colorants[8]<0) {
                 d->lumaCoefficients[0]=0.2126;
                 d->lumaCoefficients[1]=0.7152;
                 d->lumaCoefficients[2]=0.0722;
             } else {
                 d->lumaCoefficients[0]=d->colorants[2];
                 d->lumaCoefficients[1]=d->colorants[5];
                 d->lumaCoefficients[2]=d->colorants[8];
             }
         }
         return d->lumaCoefficients;
     }
 }
 
 QList<KoChannelInfo *> KoColorSpace::channels() const
 {
     return d->channels;
 }
 
 QBitArray KoColorSpace::channelFlags(bool color, bool alpha) const
 {
     QBitArray ba(d->channels.size());
     if (!color && !alpha) return ba;
 
     for (int i = 0; i < d->channels.size(); ++i) {
         KoChannelInfo * channel = d->channels.at(i);
         if ((color && channel->channelType() == KoChannelInfo::COLOR) ||
                 (alpha && channel->channelType() == KoChannelInfo::ALPHA))
             ba.setBit(i, true);
     }
     return ba;
 }
 
 void KoColorSpace::addChannel(KoChannelInfo * ci)
 {
     d->channels.push_back(ci);
 }
 bool KoColorSpace::hasCompositeOp(const QString& id) const
 {
     return d->compositeOps.contains(id);
 }
 
 QList<KoCompositeOp*> KoColorSpace::compositeOps() const
 {
     return d->compositeOps.values();
 }
 
 KoMixColorsOp* KoColorSpace::mixColorsOp() const
 {
     return d->mixColorsOp;
 }
 
 
 KoConvolutionOp* KoColorSpace::convolutionOp() const
 {
     return d->convolutionOp;
 }
 
 const KoCompositeOp * KoColorSpace::compositeOp(const QString & id) const
 {
     const QHash<QString, KoCompositeOp*>::ConstIterator it = d->compositeOps.constFind(id);
     if (it != d->compositeOps.constEnd()) {
         return it.value();
     }
     else {
         warnPigment << "Asking for non-existent composite operation " << id << ", returning " << COMPOSITE_OVER;
         return d->compositeOps.value(COMPOSITE_OVER);
     }
 }
 
 void KoColorSpace::addCompositeOp(const KoCompositeOp * op)
 {
     if (op->colorSpace()->id() == id()) {
         d->compositeOps.insert(op->id(), const_cast<KoCompositeOp*>(op));
     }
 }
 
 const KoColorConversionTransformation* KoColorSpace::toLabA16Converter() const
 {
     if (!d->transfoToLABA16) {
-        d->transfoToLABA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, KoColorSpaceRegistry::instance()->lab16(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
+        d->transfoToLABA16 = KoColorSpaceRegistry::instance()->createColorConverter(this, KoColorSpaceRegistry::instance()->lab16(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoToLABA16;
 }
 
 const KoColorConversionTransformation* KoColorSpace::fromLabA16Converter() const
 {
     if (!d->transfoFromLABA16) {
-        d->transfoFromLABA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(KoColorSpaceRegistry::instance()->lab16(), this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
+        d->transfoFromLABA16 = KoColorSpaceRegistry::instance()->createColorConverter(KoColorSpaceRegistry::instance()->lab16(), this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoFromLABA16;
 }
 const KoColorConversionTransformation* KoColorSpace::toRgbA16Converter() const
 {
     if (!d->transfoToRGBA16) {
-        d->transfoToRGBA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, KoColorSpaceRegistry::instance()->rgb16(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
+        d->transfoToRGBA16 = KoColorSpaceRegistry::instance()->createColorConverter(this, KoColorSpaceRegistry::instance()->rgb16(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoToRGBA16;
 }
 const KoColorConversionTransformation* KoColorSpace::fromRgbA16Converter() const
 {
     if (!d->transfoFromRGBA16) {
-        d->transfoFromRGBA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(KoColorSpaceRegistry::instance()->rgb16() , this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
+        d->transfoFromRGBA16 = KoColorSpaceRegistry::instance()->createColorConverter(KoColorSpaceRegistry::instance()->rgb16() , this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoFromRGBA16;
 }
 
 void KoColorSpace::toLabA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     toLabA16Converter()->transform(src, dst, nPixels);
 }
 
 void KoColorSpace::fromLabA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     fromLabA16Converter()->transform(src, dst, nPixels);
 }
 
 void KoColorSpace::toRgbA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     toRgbA16Converter()->transform(src, dst, nPixels);
 }
 
 void KoColorSpace::fromRgbA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     fromRgbA16Converter()->transform(src, dst, nPixels);
 }
 
 KoColorConversionTransformation* KoColorSpace::createColorConverter(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     if (*this == *dstColorSpace) {
         return new KoCopyColorConversionTransformation(this);
     } else {
-        return KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, dstColorSpace, renderingIntent, conversionFlags);
+        return KoColorSpaceRegistry::instance()->createColorConverter(this, dstColorSpace, renderingIntent, conversionFlags);
     }
 }
 
 bool KoColorSpace::convertPixelsTo(const quint8 * src,
                                    quint8 * dst,
                                    const KoColorSpace * dstColorSpace,
                                    quint32 numPixels,
                                    KoColorConversionTransformation::Intent renderingIntent,
                                    KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     if (*this == *dstColorSpace) {
         if (src != dst) {
             memcpy(dst, src, numPixels * sizeof(quint8) * pixelSize());
         }
     } else {
         KoCachedColorConversionTransformation cct = KoColorSpaceRegistry::instance()->colorConversionCache()->cachedConverter(this, dstColorSpace, renderingIntent, conversionFlags);
         cct.transformation()->transform(src, dst, numPixels);
     }
     return true;
 }
 
 KoColorConversionTransformation * KoColorSpace::createProofingTransform(const KoColorSpace *dstColorSpace, const KoColorSpace *proofingSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::Intent proofingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, quint8 *gamutWarning, double adaptationState) const
 {
     if (!d->iccEngine) {
         d->iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     }
     if (!d->iccEngine) return 0;
 
     return d->iccEngine->createColorProofingTransformation(this, dstColorSpace, proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning, adaptationState);
 }
 
 bool KoColorSpace::proofPixelsTo(const quint8 *src,
                                  quint8 *dst,
                                  quint32 numPixels,
                                  KoColorConversionTransformation *proofingTransform) const
 {
     proofingTransform->transform(src, dst, numPixels);
 
     //the transform is deleted in the destructor.
     return true;
 }
 
 void KoColorSpace::bitBlt(const KoColorSpace* srcSpace, const KoCompositeOp::ParameterInfo& params, const KoCompositeOp* op,
                           KoColorConversionTransformation::Intent renderingIntent,
                           KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     Q_ASSERT_X(*op->colorSpace() == *this, "KoColorSpace::bitBlt", QString("Composite op is for color space %1 (%2) while this is %3 (%4)").arg(op->colorSpace()->id()).arg(op->colorSpace()->profile()->name()).arg(id()).arg(profile()->name()).toLatin1());
 
     if(params.rows <= 0 || params.cols <= 0)
         return;
 
     if(!(*this == *srcSpace)) {
          if (preferCompositionInSourceColorSpace() &&
              srcSpace->hasCompositeOp(op->id())) {
 
              quint32           conversionDstBufferStride = params.cols * srcSpace->pixelSize();
              QVector<quint8> * conversionDstCache        = threadLocalConversionCache(params.rows * conversionDstBufferStride);
              quint8*           conversionDstData         = conversionDstCache->data();
 
              for(qint32 row=0; row<params.rows; row++) {
                  convertPixelsTo(params.dstRowStart + row * params.dstRowStride,
                                  conversionDstData  + row * conversionDstBufferStride, srcSpace, params.cols,
                                  renderingIntent, conversionFlags);
              }
 
              // FIXME: do not calculate the otherOp every time
              const KoCompositeOp *otherOp = srcSpace->compositeOp(op->id());
 
              KoCompositeOp::ParameterInfo paramInfo(params);
              paramInfo.dstRowStart  = conversionDstData;
              paramInfo.dstRowStride = conversionDstBufferStride;
              otherOp->composite(paramInfo);
 
              for(qint32 row=0; row<params.rows; row++) {
                  srcSpace->convertPixelsTo(conversionDstData  + row * conversionDstBufferStride,
                                            params.dstRowStart + row * params.dstRowStride, this, params.cols,
                                            renderingIntent, conversionFlags);
              }
 
         } else {
             quint32           conversionBufferStride = params.cols * pixelSize();
             QVector<quint8> * conversionCache        = threadLocalConversionCache(params.rows * conversionBufferStride);
             quint8*           conversionData         = conversionCache->data();
 
             for(qint32 row=0; row<params.rows; row++) {
                 srcSpace->convertPixelsTo(params.srcRowStart + row * params.srcRowStride,
                                           conversionData     + row * conversionBufferStride, this, params.cols,
                                           renderingIntent, conversionFlags);
             }
 
             KoCompositeOp::ParameterInfo paramInfo(params);
             paramInfo.srcRowStart  = conversionData;
             paramInfo.srcRowStride = conversionBufferStride;
             op->composite(paramInfo);
         }
     }
     else {
         op->composite(params);
     }
 }
 
 
 QVector<quint8> * KoColorSpace::threadLocalConversionCache(quint32 size) const
 {
     QVector<quint8> * ba = 0;
     if (!d->conversionCache.hasLocalData()) {
         ba = new QVector<quint8>(size, '0');
         d->conversionCache.setLocalData(ba);
     } else {
         ba = d->conversionCache.localData();
         if ((quint8)ba->size() < size)
             ba->resize(size);
     }
     return ba;
 }
 
 KoColorTransformation* KoColorSpace::createColorTransformation(const QString & id, const QHash<QString, QVariant> & parameters) const
 {
     KoColorTransformationFactory* factory = KoColorTransformationFactoryRegistry::instance()->get(id);
     if (!factory) return 0;
     QPair<KoID, KoID> model(colorModelId(), colorDepthId());
     QList< QPair<KoID, KoID> > models = factory->supportedModels();
     if (models.isEmpty() || models.contains(model)) {
         return factory->createTransformation(this, parameters);
     } else {
         // Find the best solution
         // TODO use the color conversion cache
         KoColorConversionTransformation* csToFallBack = 0;
         KoColorConversionTransformation* fallBackToCs = 0;
-        KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverters(this, models, csToFallBack, fallBackToCs);
+        KoColorSpaceRegistry::instance()->createColorConverters(this, models, csToFallBack, fallBackToCs);
         Q_ASSERT(csToFallBack);
         Q_ASSERT(fallBackToCs);
         KoColorTransformation* transfo = factory->createTransformation(fallBackToCs->srcColorSpace(), parameters);
         return new KoFallBackColorTransformation(csToFallBack, fallBackToCs, transfo);
     }
 }
 
 void KoColorSpace::increaseLuminosity(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     if (profile()->hasTRC()){
         //only linearise and crunch the luma if there's a TRC
         profile()->linearizeFloatValue(channelValues);
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         luma = pow(luma, 1/2.2);
         luma = qMin(1.0, luma + step);
         luma = pow(luma, 2.2);
         channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     } else {
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         luma = qMin(1.0, luma + step);
         channelValues = fromHSY(&hue, &sat, &luma);
     }
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::decreaseLuminosity(quint8 * pixel, qreal step) const {
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     if (profile()->hasTRC()){
         //only linearise and crunch the luma if there's a TRC
         profile()->linearizeFloatValue(channelValues);
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         luma = pow(luma, 1/2.2);
         if (luma-step<0.0) {
             luma=0.0;
         } else {
             luma -= step;
         }
         luma = pow(luma, 2.2);
         channelValues = fromHSY(&hue, &sat, &luma);
         profile()->delinearizeFloatValue(channelValues);
     } else {
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         if (luma-step<0.0) {
             luma=0.0;
         } else {
             luma -= step;
         }
         channelValues = fromHSY(&hue, &sat, &luma);
     }
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseSaturation(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     sat += step;
     sat = qBound(0.0, sat, 1.0);
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::decreaseSaturation(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     sat -= step;
     sat = qBound(0.0, sat, 1.0);
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseHue(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount(); //doesn't work for cmyka...
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     if (hue+step>1.0){
         hue=(hue+step)- 1.0;
     } else {
         hue += step;
     }
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::decreaseHue(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     if (hue-step<0.0){
         hue=1.0-(step-hue);
     } else {
         hue -= step;
     }
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 
 void KoColorSpace::increaseRed(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     u += step;
     u = qBound(0.0, u, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseGreen(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     u -= step;
     u = qBound(0.0, u, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 
 void KoColorSpace::increaseBlue(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     v += step;
     v = qBound(0.0, v, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 
 void KoColorSpace::increaseYellow(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     v -= step;
     v = qBound(0.0, v, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 
 QImage KoColorSpace::convertToQImage(const quint8 *data, qint32 width, qint32 height,
                                      const KoColorProfile *dstProfile,
                                      KoColorConversionTransformation::Intent renderingIntent,
                                      KoColorConversionTransformation::ConversionFlags conversionFlags) const
 
 {
     QImage img = QImage(width, height, QImage::Format_ARGB32);
 
     const KoColorSpace * dstCS = KoColorSpaceRegistry::instance()->rgb8(dstProfile);
 
     if (data)
         this->convertPixelsTo(const_cast<quint8 *>(data), img.bits(), dstCS, width * height, renderingIntent, conversionFlags);
 
     return img;
 }
 
 bool KoColorSpace::preferCompositionInSourceColorSpace() const
 {
     return false;
 }
diff --git a/libs/pigment/KoColorSpaceFactory.cpp b/libs/pigment/KoColorSpaceFactory.cpp
index 52632cef92..c71682eacf 100644
--- a/libs/pigment/KoColorSpaceFactory.cpp
+++ b/libs/pigment/KoColorSpaceFactory.cpp
@@ -1,107 +1,107 @@
 /*
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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 "KoColorSpaceFactory.h"
 
 #include "DebugPigment.h"
 
 #include <QMutexLocker>
 
 #include "KoColorProfile.h"
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 
 struct Q_DECL_HIDDEN KoColorSpaceFactory::Private {
     QList<KoColorProfile*> colorprofiles;
     QList<KoColorSpace*> colorspaces;
     QHash<QString, KoColorSpace* > availableColorspaces;
     QMutex mutex;
 #ifndef NDEBUG
     QHash<KoColorSpace*, QString> stackInformation;
 #endif
 };
 
 KoColorSpaceFactory::KoColorSpaceFactory() : d(new Private)
 {
 }
 
 KoColorSpaceFactory::~KoColorSpaceFactory()
 {
 #ifndef NDEBUG
     // Check that all color spaces have been released
     int count = 0;
     count += d->availableColorspaces.size();
 
     for(QHash<KoColorSpace*, QString>::const_iterator it = d->stackInformation.constBegin();
         it != d->stackInformation.constEnd(); ++it)
     {
         errorPigment << "*******************************************";
         errorPigment << it.key()->id() << " still in used, and grabed in: ";
         errorPigment << it.value();
     }
     if( count != d->colorspaces.size())
     {
         errorPigment << (d->colorspaces.size() - count) << " colorspaces are still used";
     }
     Q_ASSERT(count == d->colorspaces.size());
 #endif
     Q_FOREACH (KoColorSpace* cs, d->colorspaces) {
         delete cs;
     }
     Q_FOREACH (KoColorProfile* profile, d->colorprofiles) {
         KoColorSpaceRegistry::instance()->removeProfile(profile);
         delete profile;
     }
     delete d;
 }
 
-const KoColorProfile* KoColorSpaceFactory::colorProfile(const QByteArray& rawData) const
+const KoColorProfile *KoColorSpaceFactory::colorProfile(const QByteArray &rawData, KoColorSpaceFactory::ProfileRegistrationInterface *registrationInterface) const
 {
     KoColorProfile* colorProfile = createColorProfile(rawData);
     if (colorProfile && colorProfile->valid()) {
-        if (const KoColorProfile* existingProfile = KoColorSpaceRegistry::instance()->profileByName(colorProfile->name())) {
+        if (const KoColorProfile* existingProfile = registrationInterface->profileByName(colorProfile->name())) {
             delete colorProfile;
             return existingProfile;
         }
-        KoColorSpaceRegistry::instance()->addProfile(colorProfile);
+        registrationInterface->registerNewProfile(colorProfile);
         d->colorprofiles.append(colorProfile);
     }
     return colorProfile;
 }
 
 const KoColorSpace *KoColorSpaceFactory::grabColorSpace(const KoColorProfile * profile)
 {
     QMutexLocker l(&d->mutex);
     Q_ASSERT(profile);
     auto it = d->availableColorspaces.find(profile->name());
     KoColorSpace* cs;
 
     if (it == d->availableColorspaces.end()) {
         cs = createColorSpace(profile);
         if (cs) {
             d->availableColorspaces[profile->name()] = cs;
         }
     }
     else {
         cs = it.value();
     }
 
     return cs;
 }
 
diff --git a/libs/pigment/KoColorSpaceFactory.h b/libs/pigment/KoColorSpaceFactory.h
index b04a398563..8d4dac91e3 100644
--- a/libs/pigment/KoColorSpaceFactory.h
+++ b/libs/pigment/KoColorSpaceFactory.h
@@ -1,140 +1,147 @@
 /*
  *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2006-2007 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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.
  */
 #ifndef KOCOLORSPACEFACTORY_H
 #define KOCOLORSPACEFACTORY_H
 
 #include "KoColorSpaceConstants.h"
 #include "KoColorConversionTransformation.h"
 #include <KoID.h>
 #include "kritapigment_export.h"
 
 class KoColorProfile;
 class KoColorConversionTransformationFactory;
 
 /**
  * This class is used to create color spaces.
  */
 class KRITAPIGMENT_EXPORT KoColorSpaceFactory
 {
 protected:
     KoColorSpaceFactory();
 public:
     virtual ~KoColorSpaceFactory();
     /**
      * Return the unchanging name of this color space
      */
     virtual QString id() const = 0;
 
     /**
      * return the i18n'able description.
      */
     virtual QString name() const = 0;
 
     /**
      * @return true if the color space should be shown in a User Interface, or false
      *         other wise.
      */
     virtual bool userVisible() const = 0;
 
     /**
      * @return a string that identify the color model (for instance "RGB" or "CMYK" ...)
      * @see KoColorModelStandardIds.h
      */
     virtual KoID colorModelId() const = 0;
 
     /**
      * @return a string that identify the bit depth (for instance "U8" or "F16" ...)
      * @see KoColorModelStandardIds.h
      */
     virtual KoID colorDepthId() const = 0;
 
     /**
      * @param profile a pointer to a color profile
      * @return true if the color profile can be used by a color space created by
      * this factory
      */
     virtual bool profileIsCompatible(const KoColorProfile* profile) const = 0;
 
     /**
      * @return the name of the color space engine for this color space, or "" if none
      */
     virtual QString colorSpaceEngine() const = 0;
 
     /**
      * @return true if the color space supports High-Dynamic Range.
      */
     virtual bool isHdr() const = 0;
 
     /**
      * @return the reference depth, that is for a color space where all channels have the same
      * depth, this is the depth of one channel, for a color space with different bit depth for
      * each channel, it's usually the highest bit depth. This value is used by the Color
      * Conversion System to check if a lost of bit depth during a color conversion is
      * acceptable, for instance when converting from RGB32bit to XYZ16bit, it's acceptable to go
      * through a conversion to RGB16bit, while it's not the case for RGB32bit to XYZ32bit.
      */
     virtual int referenceDepth() const = 0;
 
     /**
      * @return the list of color conversion provided by this colorspace, the factories
      * constructed by this functions are owned by the caller of the function
      */
     virtual QList<KoColorConversionTransformationFactory*> colorConversionLinks() const = 0;
 
     /**
      * @return the cost of the usage of the colorspace in the conversion graph. The higher the cost,
      * the less probably the color space will be chosen for the conversion.
      */
     virtual int crossingCost() const = 0;
 
     /**
      * Returns the default icc profile for use with this colorspace. This may be ""
      *
      * @return the default icc profile name
      */
     virtual QString defaultProfile() const = 0;
 
+    struct ProfileRegistrationInterface
+    {
+        virtual ~ProfileRegistrationInterface() {}
+        virtual const KoColorProfile* profileByName(const QString &profileName) const = 0;
+        virtual void registerNewProfile(KoColorProfile *profile) = 0;
+    };
+
     /**
      * Create a color profile from a memory array, if possible, otherwise return 0.
      * This will replace the existing profile with the name in the KoColorSpaceRegistry
      *
      * This will call the decendant's createColorProfile()
      */
-    const KoColorProfile* colorProfile(const QByteArray& rawData) const;
+    const KoColorProfile* colorProfile(const QByteArray& rawData, ProfileRegistrationInterface *registrationInterface) const;
 
     /**
      * Create or reuse the existing colorspace for the given profile.
      *
      * This will call the decendant's createColorSpace
      */
     const KoColorSpace *grabColorSpace(const KoColorProfile *profile);
 
 protected:
     /**
      * creates a color space using the given profile.
      */
     virtual KoColorSpace *createColorSpace(const KoColorProfile *) const = 0;
     virtual KoColorProfile* createColorProfile(const QByteArray& rawData) const = 0;
 private:
     struct Private;
     Private* const d;
 };
 
 #endif // KOCOLORSPACEFACTORY_H
diff --git a/libs/pigment/KoColorSpaceRegistry.cpp b/libs/pigment/KoColorSpaceRegistry.cpp
index 2ffa87b175..353e4b3de2 100644
--- a/libs/pigment/KoColorSpaceRegistry.cpp
+++ b/libs/pigment/KoColorSpaceRegistry.cpp
@@ -1,753 +1,818 @@
 /*
  *  Copyright (c) 2003 Patrick Julien  <freak@codepimps.org>
  *  Copyright (c) 2004,2010 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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 "KoColorSpaceRegistry.h"
 
 #include <QHash>
 
 #include <QReadWriteLock>
 #include <QStringList>
 #include <QDir>
 #include <QGlobalStatic>
 
 #include "KoPluginLoader.h"
 #include "KoGenericRegistry.h"
 #include "DebugPigment.h"
 #include "KoBasicHistogramProducers.h"
 #include "KoColorSpace.h"
 #include "KoColorProfile.h"
 #include "KoColorConversionCache.h"
 #include "KoColorConversionSystem.h"
 
 #include "colorspaces/KoAlphaColorSpace.h"
 #include "colorspaces/KoLabColorSpace.h"
 #include "colorspaces/KoRgbU16ColorSpace.h"
 #include "colorspaces/KoRgbU8ColorSpace.h"
 #include "colorspaces/KoSimpleColorSpaceEngine.h"
 #include "KoColorSpace_p.h"
 
+#include "kis_assert.h"
+#include "KoColorProfileStorage.h"
+#include <KisReadWriteLockPolicy.h>
+
+
 Q_GLOBAL_STATIC(KoColorSpaceRegistry, s_instance)
 
 
 struct Q_DECL_HIDDEN KoColorSpaceRegistry::Private {
+
+    // interface for KoColorSpaceFactory
+    struct ProfileRegistrationInterface;
+    // interface for KoColorConversionSystem
+    struct ConversionSystemInterface;
+
+
+    Private(KoColorSpaceRegistry *_q) : q(_q) {}
+
+    KoColorSpaceRegistry *q;
+
     KoGenericRegistry<KoColorSpaceFactory *> colorSpaceFactoryRegistry;
-    QList<KoColorSpaceFactory *> localFactories;
-    QHash<QString, KoColorProfile * > profileMap;
-    QHash<QByteArray, KoColorProfile * > profileUniqueIdMap;
-    QHash<QString, QString> profileAlias;
+    KoColorProfileStorage profileStorage;
     QHash<QString, const KoColorSpace *> csMap;
+    QScopedPointer<ConversionSystemInterface> conversionSystemInterface;
     KoColorConversionSystem *colorConversionSystem;
     KoColorConversionCache* colorConversionCache;
     const KoColorSpace *rgbU8sRGB;
     const KoColorSpace *lab16sLAB;
     const KoColorSpace *alphaCs;
     const KoColorSpace *alphaU16Cs;
 #ifdef HAVE_OPENEXR
     const KoColorSpace *alphaF16Cs;
 #endif
     const KoColorSpace *alphaF32Cs;
     QReadWriteLock registrylock;
 
-    void populateUniqueIdMap();
+    /**
+     * The function checks if a colorspace with a certain id and profile name can be found in the cache
+     * NOTE: the function doesn't take any lock but it needs to be called inside a d->registryLock
+     * locked either in read or write.
+     * @param csId The colorspace id
+     * @param profileName The colorspace profile name
+     * @retval KoColorSpace The matching colorspace
+     * @retval 0 Null pointer if not match
+     */
+    const KoColorSpace* getCachedColorSpaceImpl(const QString & csId, const QString & profileName) const;
+
+    QString idsToCacheName(const QString & csId, const QString & profileName) const;
+    QString defaultProfileForCsIdImpl(const QString &csID);
+    const KoColorProfile * profileForCsIdWithFallbackImpl(const QString &csID, const QString &profileName);
+    QString colorSpaceIdImpl(const QString & colorModelId, const QString & colorDepthId) const;
+
+    const KoColorSpace *lazyCreateColorSpaceImpl(const QString &csID, const KoColorProfile *profile);
+
+    /**
+     * Return a colorspace that works with the parameter profile.
+     * @param profileName the name of the KoColorProfile to be combined with the colorspace
+     * @return the wanted colorspace, or 0 when the cs and profile can not be combined.
+     */
+    template<class LockPolicy = NormalLockPolicy>
+    const KoColorSpace * colorSpace1(const QString &colorSpaceId, const QString &pName = QString());
+
+    /**
+     * Return a colorspace that works with the parameter profile.
+     * @param colorSpaceId the ID string of the colorspace that you want to have returned
+     * @param profile the profile be combined with the colorspace
+     * @return the wanted colorspace, or 0 when the cs and profile can not be combined.
+     */
+    const KoColorSpace * colorSpace1(const QString &colorSpaceId, const KoColorProfile *profile);
+};
+
+struct KoColorSpaceRegistry::Private::ConversionSystemInterface : public KoColorConversionSystem::RegistryInterface
+{
+    ConversionSystemInterface(KoColorSpaceRegistry *parentRegistry)
+        : q(parentRegistry)
+    {
+    }
+
+    const KoColorSpace * colorSpace(const QString & colorModelId, const QString & colorDepthId, const QString &profileName) {
+        return q->d->colorSpace1<NoLockPolicy>(q->d->colorSpaceIdImpl(colorModelId, colorDepthId), profileName);
+    }
+
+    const KoColorSpaceFactory* colorSpaceFactory(const QString &colorModelId, const QString &colorDepthId) const {
+        return q->d->colorSpaceFactoryRegistry.get(q->d->colorSpaceIdImpl(colorModelId, colorDepthId));
+    }
+
+    QList<const KoColorProfile *>  profilesFor(const KoColorSpaceFactory * csf) const {
+        return q->d->profileStorage.profilesFor(csf);
+    }
+
+    QList<const KoColorSpaceFactory*> colorSpacesFor(const KoColorProfile* profile) const {
+        QList<const KoColorSpaceFactory*> csfs;
+        Q_FOREACH (KoColorSpaceFactory* csf, q->d->colorSpaceFactoryRegistry.values()) {
+            if (csf->profileIsCompatible(profile)) {
+                csfs.push_back(csf);
+            }
+        }
+        return csfs;
+    }
+
+private:
+    KoColorSpaceRegistry *q;
 };
 
 KoColorSpaceRegistry* KoColorSpaceRegistry::instance()
 {
     if (!s_instance.exists()) {
         s_instance->init();
     }
     return s_instance;
 }
 
 
 void KoColorSpaceRegistry::init()
 {
     d->rgbU8sRGB = 0;
     d->lab16sLAB = 0;
     d->alphaCs = 0;
     d->alphaU16Cs = 0;
 #ifdef HAVE_OPENEXR
     d->alphaF16Cs = 0;
 #endif
     d->alphaF32Cs = 0;
 
-    d->colorConversionSystem = new KoColorConversionSystem;
+    d->conversionSystemInterface.reset(new Private::ConversionSystemInterface(this));
+    d->colorConversionSystem = new KoColorConversionSystem(d->conversionSystemInterface.data());
     d->colorConversionCache = new KoColorConversionCache;
 
     KoColorSpaceEngineRegistry::instance()->add(new KoSimpleColorSpaceEngine());
 
     addProfile(new KoDummyColorProfile);
 
     // Create the built-in colorspaces
-    d->localFactories
+    QList<KoColorSpaceFactory *> localFactories;
+    localFactories
             << new KoAlphaColorSpaceFactory()
             << new KoAlphaU16ColorSpaceFactory()
            #ifdef HAVE_OPENEXR
             << new KoAlphaF16ColorSpaceFactory()
            #endif
             << new KoAlphaF32ColorSpaceFactory()
             << new KoLabColorSpaceFactory()
             << new KoRgbU8ColorSpaceFactory()
             << new KoRgbU16ColorSpaceFactory();
 
-    Q_FOREACH (KoColorSpaceFactory *factory, d->localFactories) {
+    Q_FOREACH (KoColorSpaceFactory *factory, localFactories) {
         add(factory);
     }
 
     KoPluginLoader::PluginsConfig config;
     config.whiteList = "ColorSpacePlugins";
     config.blacklist = "ColorSpacePluginsDisabled";
     config.group = "calligra";
     KoPluginLoader::instance()->load("Calligra/ColorSpace", "[X-Pigment-PluginVersion] == 28", config);
 
     KoPluginLoader::PluginsConfig configExtensions;
     configExtensions.whiteList = "ColorSpaceExtensionsPlugins";
     configExtensions.blacklist = "ColorSpaceExtensionsPluginsDisabled";
     configExtensions.group = "calligra";
     KoPluginLoader::instance()->load("Calligra/ColorSpaceExtension", "[X-Pigment-PluginVersion] == 28", configExtensions);
 
 
     dbgPigment << "Loaded the following colorspaces:";
     Q_FOREACH (const KoID& id, listKeys()) {
         dbgPigment << "\t" << id.id() << "," << id.name();
     }
 }
 
-KoColorSpaceRegistry::KoColorSpaceRegistry() : d(new Private())
+KoColorSpaceRegistry::KoColorSpaceRegistry() : d(new Private(this))
 {
     d->colorConversionSystem = 0;
     d->colorConversionCache = 0;
 }
 
 KoColorSpaceRegistry::~KoColorSpaceRegistry()
 {
     // Just leak on exit... It's faster.
 //    delete d->colorConversionSystem;
 //    Q_FOREACH (KoColorProfile* profile, d->profileMap) {
 //        delete profile;
 //    }
 //    d->profileMap.clear();
 
 //    Q_FOREACH (const KoColorSpace * cs, d->csMap) {
 //        cs->d->deletability = OwnedByRegistryRegistryDeletes;
 //    }
 //    d->csMap.clear();
 
 //    // deleting colorspaces calls a function in the cache
 //    delete d->colorConversionCache;
 //    d->colorConversionCache = 0;
 
 //    // Delete the colorspace factories
 //    qDeleteAll(d->localFactories);
 
     delete d;
 }
 
 void KoColorSpaceRegistry::add(KoColorSpaceFactory* item)
 {
-    {
-        QWriteLocker l(&d->registrylock);
-        d->colorSpaceFactoryRegistry.add(item);
-    }
+    QWriteLocker l(&d->registrylock);
+    d->colorSpaceFactoryRegistry.add(item);
     d->colorConversionSystem->insertColorSpace(item);
 }
 
 void KoColorSpaceRegistry::remove(KoColorSpaceFactory* item)
 {
-    d->registrylock.lockForRead();
+    QWriteLocker l(&d->registrylock);
+
     QList<QString> toremove;
     Q_FOREACH (const KoColorSpace * cs, d->csMap) {
         if (cs->id() == item->id()) {
-            toremove.push_back(idsToCacheName(cs->id(), cs->profile()->name()));
+            toremove.push_back(d->idsToCacheName(cs->id(), cs->profile()->name()));
             cs->d->deletability = OwnedByRegistryRegistryDeletes;
         }
     }
-    d->registrylock.unlock();
-    d->registrylock.lockForWrite();
+
     Q_FOREACH (const QString& id, toremove) {
         d->csMap.remove(id);
         // TODO: should not it delete the color space when removing it from the map ?
     }
     d->colorSpaceFactoryRegistry.remove(item->id());
-    d->registrylock.unlock();
 }
 
 void KoColorSpaceRegistry::addProfileAlias(const QString& name, const QString& to)
 {
-    QWriteLocker l(&d->registrylock);
-    d->profileAlias[name] = to;
+    d->profileStorage.addProfileAlias(name, to);
 }
 
-QString KoColorSpaceRegistry::profileAlias(const QString& _name) const
+QString KoColorSpaceRegistry::profileAlias(const QString& name) const
 {
-    QReadLocker l(&d->registrylock);
-    return d->profileAlias.value(_name, _name);
+    return d->profileStorage.profileAlias(name);
 }
 
-const KoColorProfile *  KoColorSpaceRegistry::profileByName(const QString & _name) const
+const KoColorProfile*  KoColorSpaceRegistry::profileByName(const QString &name) const
 {
-    QReadLocker l(&d->registrylock);
-    return d->profileMap.value( profileAlias(_name), 0);
-}
-
-void KoColorSpaceRegistry::Private::populateUniqueIdMap()
-{
-    QWriteLocker l(&registrylock);
-    profileUniqueIdMap.clear();
-
-    for (auto it = profileMap.constBegin();
-         it != profileMap.constEnd();
-         ++it) {
-
-        KoColorProfile *profile = it.value();
-        QByteArray id = profile->uniqueId();
-
-        if (!id.isEmpty()) {
-            profileUniqueIdMap.insert(id, profile);
-        }
-    }
+    return d->profileStorage.profileByName(name);
 }
 
 const KoColorProfile *  KoColorSpaceRegistry::profileByUniqueId(const QByteArray &id) const
 {
-    {
-        QReadLocker l(&d->registrylock);
-        if (d->profileUniqueIdMap.isEmpty()) {
-            l.unlock();
-            d->populateUniqueIdMap();
-            l.relock();
-        }
-        return d->profileUniqueIdMap.value(id, 0);
-    }
+    return d->profileStorage.profileByUniqueId(id);
 }
 
-
-QList<const KoColorProfile *>  KoColorSpaceRegistry::profilesFor(const QString &id) const
+QList<const KoColorProfile *>  KoColorSpaceRegistry::profilesFor(const QString &csID) const
 {
-    return profilesFor(d->colorSpaceFactoryRegistry.value(id));
-}
-
-const KoColorSpace *  KoColorSpaceRegistry::colorSpace(const KoID &csID, const QString & profileName)
-{
-    return colorSpace(csID.id(), profileName);
+    QReadLocker l(&d->registrylock);
+    return d->profileStorage.profilesFor(d->colorSpaceFactoryRegistry.value(csID));
 }
 
 const KoColorSpace * KoColorSpaceRegistry::colorSpace(const QString & colorModelId, const QString & colorDepthId, const KoColorProfile *profile)
 {
-    return colorSpace(colorSpaceId(colorModelId, colorDepthId), profile);
+    return d->colorSpace1(colorSpaceId(colorModelId, colorDepthId), profile);
 }
 
 const KoColorSpace * KoColorSpaceRegistry::colorSpace(const QString & colorModelId, const QString & colorDepthId, const QString &profileName)
 {
-    return colorSpace(colorSpaceId(colorModelId, colorDepthId), profileName);
+    return d->colorSpace1(colorSpaceId(colorModelId, colorDepthId), profileName);
 }
 
-QList<const KoColorProfile *>  KoColorSpaceRegistry::profilesFor(const KoColorSpaceFactory * csf) const
+const KoColorSpace * KoColorSpaceRegistry::colorSpace(const QString & colorModelId, const QString & colorDepthId)
 {
-    QReadLocker l(&d->registrylock);
-    QList<const KoColorProfile *>  profiles;
-    if (csf == 0)
-        return profiles;
-
-    QHash<QString, KoColorProfile * >::Iterator it;
-    for (it = d->profileMap.begin(); it != d->profileMap.end(); ++it) {
-        KoColorProfile *  profile = it.value();
-        if (csf->profileIsCompatible(profile)) {
-            Q_ASSERT(profile);
-            //         if (profile->colorSpaceSignature() == csf->colorSpaceSignature()) {
-            profiles.push_back(profile);
-        }
-    }
-    return profiles;
+    return d->colorSpace1(colorSpaceId(colorModelId, colorDepthId));
 }
 
-QList<const KoColorSpaceFactory*> KoColorSpaceRegistry::colorSpacesFor(const KoColorProfile* _profile) const
+bool KoColorSpaceRegistry::profileIsCompatible(const KoColorProfile *profile, const QString &colorSpaceId)
 {
     QReadLocker l(&d->registrylock);
-    QList<const KoColorSpaceFactory*> csfs;
-    Q_FOREACH (KoColorSpaceFactory* csf, d->colorSpaceFactoryRegistry.values()) {
-        if (csf->profileIsCompatible(_profile)) {
-            csfs.push_back(csf);
-        }
-    }
-    return csfs;
-}
+    KoColorSpaceFactory *csf = d->colorSpaceFactoryRegistry.value(colorSpaceId);
 
-QList<const KoColorProfile *>  KoColorSpaceRegistry::profilesFor(const KoID& id) const
-{
-    return profilesFor(id.id());
+    return csf ? csf->profileIsCompatible(profile) : false;
 }
 
 void KoColorSpaceRegistry::addProfileToMap(KoColorProfile *p)
 {
-    Q_ASSERT(p);
-    if (p->valid()) {
-        d->profileMap[p->name()] = p;
-        if (!d->profileUniqueIdMap.isEmpty()) {
-            d->profileUniqueIdMap.insert(p->uniqueId(), p);
-        }
-    }
+    d->profileStorage.addProfile(p);
 }
 
 void KoColorSpaceRegistry::addProfile(KoColorProfile *p)
 {
-    Q_ASSERT(p);
+    if (!p->valid()) return;
+
+    QWriteLocker locker(&d->registrylock);
     if (p->valid()) {
         addProfileToMap(p);
         d->colorConversionSystem->insertColorProfile(p);
     }
 }
 
 void KoColorSpaceRegistry::addProfile(const KoColorProfile* profile)
 {
     addProfile(profile->clone());
 }
 
 void KoColorSpaceRegistry::removeProfile(KoColorProfile* profile)
 {
-    d->profileMap.remove(profile->name());
-    if (!d->profileUniqueIdMap.isEmpty()) {
-        d->profileUniqueIdMap.remove(profile->uniqueId());
-    }
+    d->profileStorage.removeProfile(profile);
+    // FIXME: how about removing it from conversion system?
 }
 
-const KoColorSpace* KoColorSpaceRegistry::getCachedColorSpace(const QString & csID, const QString & profileName) const
+const KoColorSpace* KoColorSpaceRegistry::Private::getCachedColorSpaceImpl(const QString & csID, const QString & profileName) const
 {
-    auto it = d->csMap.find(idsToCacheName(csID, profileName));
+    auto it = csMap.find(idsToCacheName(csID, profileName));
 
-    if (it != d->csMap.end()) {
-            return it.value();
+    if (it != csMap.end()) {
+        return it.value();
     }
 
     return 0;
 }
 
-QString KoColorSpaceRegistry::idsToCacheName(const QString & csID, const QString & profileName) const
+QString KoColorSpaceRegistry::Private::idsToCacheName(const QString & csID, const QString & profileName) const
 {
     return csID + "<comb>" + profileName;
 }
 
-const KoColorSpaceFactory* KoColorSpaceRegistry::colorSpaceFactory(const QString &colorSpaceId) const
+QString KoColorSpaceRegistry::defaultProfileForColorSpace(const QString &colorSpaceId) const
 {
     QReadLocker l(&d->registrylock);
-    return d->colorSpaceFactoryRegistry.get(colorSpaceId);
+    return d->defaultProfileForCsIdImpl(colorSpaceId);
 }
 
-const KoColorSpace * KoColorSpaceRegistry::colorSpace(const QString &csID, const QString &pName)
+KoColorConversionTransformation *KoColorSpaceRegistry::createColorConverter(const KoColorSpace *srcColorSpace, const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
-    QString profileName = pName;
+    QWriteLocker l(&d->registrylock);
+    return d->colorConversionSystem->createColorConverter(srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
+}
 
-    if (profileName.isEmpty()) {
-        QReadLocker l(&d->registrylock);
-        KoColorSpaceFactory *csf = d->colorSpaceFactoryRegistry.value(csID);
+void KoColorSpaceRegistry::createColorConverters(const KoColorSpace *colorSpace, const QList<QPair<KoID, KoID> > &possibilities, KoColorConversionTransformation *&fromCS, KoColorConversionTransformation *&toCS) const
+{
+    QWriteLocker l(&d->registrylock);
+    d->colorConversionSystem->createColorConverters(colorSpace, possibilities, fromCS, toCS);
+}
 
-        if (!csf) {
-            dbgPigmentCSRegistry << "Unknown color space type : " << csID;
-            return 0;
-        }
+QString KoColorSpaceRegistry::Private::defaultProfileForCsIdImpl(const QString &csID)
+{
+    QString defaultProfileName;
 
-        profileName = csf->defaultProfile();
+    KoColorSpaceFactory *csf = colorSpaceFactoryRegistry.value(csID);
+    if (csf) {
+        defaultProfileName = csf->defaultProfile();
+    } else {
+        dbgPigmentCSRegistry << "Unknown color space type : " << csID;
     }
 
-    if (profileName.isEmpty()) {
-        return 0;
-    }
+    return defaultProfileName;
+}
 
-    const KoColorSpace *cs = 0;
-    {
-        QReadLocker l(&d->registrylock);
-        cs = getCachedColorSpace(csID, profileName);
-    }
+const KoColorProfile *KoColorSpaceRegistry::Private::profileForCsIdWithFallbackImpl(const QString &csID, const QString &profileName)
+{
+    const KoColorProfile *profile = 0;
 
-    if (!cs) {
-        KoColorSpaceFactory *csf = d->colorSpaceFactoryRegistry.value(csID);
+    // last attempt at getting a profile, sometimes the default profile, like adobe cmyk isn't available.
+    profile = profileStorage.profileByName(profileName);
+    if (!profile) {
+        dbgPigmentCSRegistry << "Profile not found :" << profileName;
 
-        if (!csf) {
-            dbgPigmentCSRegistry << "Unknown color space type :" << csf;
-            return 0;
-        }
+        // first try: default
+        profile = profileStorage.profileByName(defaultProfileForCsIdImpl(csID));
 
-        // last attempt at getting a profile, sometimes the default profile, like adobe cmyk isn't available.
-        const KoColorProfile *p = profileByName(profileName);
-        if (!p) {
-            dbgPigmentCSRegistry << "Profile not found :" << profileName;
-
-            /**
-             * If the requested profile is not available, try fetching the
-             * default one
-             */
-            profileName = csf->defaultProfile();
-            p = profileByName(profileName);
-
-            /**
-             * If there is no luck, try to fetch the first one
-             */
-            if (!p) {
-                QList<const KoColorProfile *> profiles = profilesFor(csID);
-                if (!profiles.isEmpty()) {
-                    p = profiles[0];
-                    Q_ASSERT(p);
-                }
+        if (!profile) {
+            // second try: first profile in the list
+            QList<const KoColorProfile *> profiles = profileStorage.profilesFor(colorSpaceFactoryRegistry.value(csID));
+            if (profiles.isEmpty() || !profiles.first()) {
+                dbgPigmentCSRegistry << "Couldn't fetch a fallback profile:" << profileName;
+                return 0;
             }
+
+            profile = profiles.first();
         }
+    }
+
+    return profile;
+}
+
+const KoColorSpace *KoColorSpaceRegistry::Private::lazyCreateColorSpaceImpl(const QString &csID, const KoColorProfile *profile)
+{
+    const KoColorSpace *cs = 0;
 
-        // We did our best, but still have no profile: and since csf->grabColorSpace
-        // needs the profile to find the colorspace, we have to give up.
-        if (!p) {
+    /*
+     * We need to check again here, a thread requesting the same colorspace could've added it
+     * already, in between the read unlock and write lock.
+     * TODO: We also potentially changed profileName content, which means we maybe are going to
+     * create a colorspace that's actually in the space registry cache, but currently this might
+     * not be an issue because the colorspace should be cached also by the factory, so it won't
+     * create a new instance. That being said, having two caches with the same stuff doesn't make
+     * much sense.
+     */
+    cs = getCachedColorSpaceImpl(csID, profile->name());
+    if (!cs) {
+        KoColorSpaceFactory *csf = colorSpaceFactoryRegistry.value(csID);
+        cs = csf->grabColorSpace(profile);
+        if (!cs) {
+            dbgPigmentCSRegistry << "Unable to create color space";
             return 0;
         }
-        profileName = p->name();
-
-        QWriteLocker l(&d->registrylock);
-        /*
-         * We need to check again here, a thread requesting the same colorspace could've added it
-         * already, in between the read unlock and write lock.
-         * TODO: We also potentially changed profileName content, which means we maybe are going to
-         * create a colorspace that's actually in the space registry cache, but currently this might
-         * not be an issue because the colorspace should be cached also by the factory, so it won't
-         * create a new instance. That being said, having two caches with the same stuff doesn't make
-         * much sense.
-         */
-        cs = getCachedColorSpace(csID, profileName);
-        if (!cs) {
-            cs = csf->grabColorSpace(p);
-            if (!cs) {
-                dbgPigmentCSRegistry << "Unable to create color space";
-                return 0;
-            }
 
-            dbgPigmentCSRegistry << "colorspace count: " << d->csMap.count()
-                                 << ", adding name: " << idsToCacheName(cs->id(), cs->profile()->name())
-                                 << "\n\tcsID" << csID
-                                 << "\n\tprofileName" << profileName
-                                 << "\n\tcs->id()" << cs->id()
-                                 << "\n\tcs->profile()->name()" << cs->profile()->name()
-                                 << "\n\tpName" << pName;
-            Q_ASSERT(cs->id() == csID);
-            Q_ASSERT(cs->profile()->name() == profileName);
-            d->csMap[idsToCacheName(cs->id(), cs->profile()->name())] = cs;
-            cs->d->deletability = OwnedByRegistryDoNotDelete;
+        dbgPigmentCSRegistry << "colorspace count: " << csMap.count()
+                             << ", adding name: " << idsToCacheName(cs->id(), cs->profile()->name())
+                             << "\n\tcsID" << csID
+                             << "\n\tcs->id()" << cs->id()
+                             << "\n\tcs->profile()->name()" << cs->profile()->name()
+                             << "\n\tprofile->name()" << profile->name();
+        Q_ASSERT(cs->id() == csID);
+        Q_ASSERT(cs->profile()->name() == profile->name());
+        csMap[idsToCacheName(cs->id(), cs->profile()->name())] = cs;
+        cs->d->deletability = OwnedByRegistryDoNotDelete;
+    }
+
+    return cs;
+}
+
+template<class LockPolicy>
+const KoColorSpace * KoColorSpaceRegistry::Private::colorSpace1(const QString &csID, const QString &pName)
+{
+    QString profileName = pName;
+
+    const KoColorSpace *cs = 0;
+
+    {
+        typename LockPolicy::ReadLocker l(&registrylock);
+
+        if (profileName.isEmpty()) {
+            profileName = defaultProfileForCsIdImpl(csID);
+            if (profileName.isEmpty()) return 0;
         }
+
+        // quick attempt to fetch a cached color space
+        cs = getCachedColorSpaceImpl(csID, profileName);
+    }
+
+    if (!cs) {
+        // slow attemt to create a color space
+        typename LockPolicy::WriteLocker l(&registrylock);
+
+        const KoColorProfile *profile =
+            profileForCsIdWithFallbackImpl(csID, profileName);
+
+        // until kis_asert.h is not available in 3.1, use this combo
+        Q_ASSERT(profile);
+        if (!profile) return 0;
+
+        cs = lazyCreateColorSpaceImpl(csID, profile);
     }
     else {
-        Q_ASSERT(cs->id() == csID);
-        Q_ASSERT(cs->profile()->name() == profileName);
+        KIS_SAFE_ASSERT_RECOVER_NOOP(cs->id() == csID);
+        KIS_SAFE_ASSERT_RECOVER_NOOP(cs->profile()->name() == profileName);
     }
 
     return cs;
 }
 
 
-const KoColorSpace * KoColorSpaceRegistry::colorSpace(const QString &csID, const KoColorProfile *profile)
+const KoColorSpace * KoColorSpaceRegistry::Private::colorSpace1(const QString &csID, const KoColorProfile *profile)
 {
     if (csID.isEmpty()) {
         return 0;
+    } else if (!profile) {
+        return colorSpace1(csID);
     }
-    if (profile) {
-        d->registrylock.lockForRead();
-        const KoColorSpace *cs = getCachedColorSpace(csID, profile->name());
-        d->registrylock.unlock();
 
-        if (!d->profileMap.contains(profile->name())) {
-            addProfile(profile);
-        }
+    const KoColorSpace *cs = 0;
 
-        if (!cs) {
-            // The profile was not stored and thus not the combination either
-            d->registrylock.lockForRead();
-            KoColorSpaceFactory *csf = d->colorSpaceFactoryRegistry.value(csID);
-            d->registrylock.unlock();
-            if (!csf) {
-                dbgPigmentCSRegistry << "Unknown color space type :" << csf;
-                return 0;
-            }
-            if (!csf->profileIsCompatible(profile ) ) {
-                return 0;
-            }
+    {
+        QReadLocker l(&registrylock);
+        cs = getCachedColorSpaceImpl(csID, profile->name());
+    }
 
-            QWriteLocker l(&d->registrylock);
-            // Check again, anything could've happened between the unlock and the write lock
-            cs = getCachedColorSpace(csID, profile->name());
-            if (!cs) {
-                cs = csf->grabColorSpace(profile);
-                if (!cs)
-                    return 0;
-
-                QString name = idsToCacheName(csID, profile->name());
-                d->csMap[name] = cs;
-                cs->d->deletability = OwnedByRegistryDoNotDelete;
-                dbgPigmentCSRegistry << "colorspace count: " << d->csMap.count() << ", adding name: " << name;
-            }
+    // the profile should have already been added to the registry by createColorProfile() method
+    KIS_SAFE_ASSERT_RECOVER(profileStorage.containsProfile(profile)) {
+        // warning! locking happens inside addProfile!
+        q->addProfile(profile);
+    }
+
+    if (!cs) {
+        // The profile was not stored and thus not the combination either
+        QWriteLocker l(&registrylock);
+        KoColorSpaceFactory *csf = colorSpaceFactoryRegistry.value(csID);
+
+        if (!csf) {
+            dbgPigmentCSRegistry << "Unknown color space type :" << csf;
+            return 0;
         }
 
-        return cs;
-    } else {
-        return colorSpace(csID);
+        if (!csf->profileIsCompatible(profile)) {
+            dbgPigmentCSRegistry << "Profile is not compatible:" << csf << profile->name();
+            return 0;
+        }
+
+        cs = lazyCreateColorSpaceImpl(csID, profile);
     }
+
+    return cs;
 }
 
 const KoColorSpace * KoColorSpaceRegistry::alpha8()
 {
     if (!d->alphaCs) {
-        d->alphaCs = colorSpace(KoAlphaColorSpace::colorSpaceId());
+        d->alphaCs = d->colorSpace1(KoAlphaColorSpace::colorSpaceId());
     }
     Q_ASSERT(d->alphaCs);
     return d->alphaCs;
 }
 
 const KoColorSpace * KoColorSpaceRegistry::alpha16()
 {
     if (!d->alphaU16Cs) {
-        d->alphaU16Cs = colorSpace(KoAlphaU16ColorSpace::colorSpaceId());
+        d->alphaU16Cs = d->colorSpace1(KoAlphaU16ColorSpace::colorSpaceId());
     }
     Q_ASSERT(d->alphaU16Cs);
     return d->alphaU16Cs;
 }
 
 #ifdef HAVE_OPENEXR
 const KoColorSpace * KoColorSpaceRegistry::alpha16f()
 {
     if (!d->alphaF16Cs) {
-        d->alphaF16Cs = colorSpace(KoAlphaF16ColorSpace::colorSpaceId());
+        d->alphaF16Cs = d->colorSpace1(KoAlphaF16ColorSpace::colorSpaceId());
     }
     Q_ASSERT(d->alphaF16Cs);
     return d->alphaF16Cs;
 }
 #endif
 
 const KoColorSpace * KoColorSpaceRegistry::alpha32f()
 {
     if (!d->alphaF32Cs) {
-        d->alphaF32Cs = colorSpace(KoAlphaF32ColorSpace::colorSpaceId());
+        d->alphaF32Cs = d->colorSpace1(KoAlphaF32ColorSpace::colorSpaceId());
     }
     Q_ASSERT(d->alphaF32Cs);
     return d->alphaF32Cs;
 }
 
 
 const KoColorSpace * KoColorSpaceRegistry::rgb8(const QString &profileName)
 {
     if (profileName.isEmpty()) {
         if (!d->rgbU8sRGB) {
-            d->rgbU8sRGB = colorSpace(KoRgbU8ColorSpace::colorSpaceId());
+            d->rgbU8sRGB = d->colorSpace1(KoRgbU8ColorSpace::colorSpaceId());
         }
         Q_ASSERT(d->rgbU8sRGB);
         return d->rgbU8sRGB;
     }
-    return colorSpace(KoRgbU8ColorSpace::colorSpaceId(), profileName);
+    return d->colorSpace1(KoRgbU8ColorSpace::colorSpaceId(), profileName);
 }
 
 const KoColorSpace * KoColorSpaceRegistry::rgb8(const KoColorProfile * profile)
 {
     if (profile == 0) {
         if (!d->rgbU8sRGB) {
-            d->rgbU8sRGB = colorSpace(KoRgbU8ColorSpace::colorSpaceId());
+            d->rgbU8sRGB = d->colorSpace1(KoRgbU8ColorSpace::colorSpaceId());
         }
         Q_ASSERT(d->rgbU8sRGB);
         return d->rgbU8sRGB;
     }
-    return colorSpace(KoRgbU8ColorSpace::colorSpaceId(), profile);
+    return d->colorSpace1(KoRgbU8ColorSpace::colorSpaceId(), profile);
 }
 
 const KoColorSpace * KoColorSpaceRegistry::rgb16(const QString &profileName)
 {
-    return colorSpace(KoRgbU16ColorSpace::colorSpaceId(), profileName);
+    return d->colorSpace1(KoRgbU16ColorSpace::colorSpaceId(), profileName);
 }
 
 const KoColorSpace * KoColorSpaceRegistry::rgb16(const KoColorProfile * profile)
 {
-    return colorSpace(KoRgbU16ColorSpace::colorSpaceId(), profile);
+    return d->colorSpace1(KoRgbU16ColorSpace::colorSpaceId(), profile);
 }
 
 const KoColorSpace * KoColorSpaceRegistry::lab16(const QString &profileName)
 {
     if (profileName.isEmpty()) {
         if (!d->lab16sLAB) {
-            d->lab16sLAB = colorSpace(KoLabColorSpace::colorSpaceId(), profileName);
+            d->lab16sLAB = d->colorSpace1(KoLabColorSpace::colorSpaceId());
         }
         return d->lab16sLAB;
     }
-    return colorSpace(KoLabColorSpace::colorSpaceId(), profileName);
+    return d->colorSpace1(KoLabColorSpace::colorSpaceId(), profileName);
 }
 
 const KoColorSpace * KoColorSpaceRegistry::lab16(const KoColorProfile * profile)
 {
     if (profile == 0) {
         if (!d->lab16sLAB) {
-            d->lab16sLAB = colorSpace(KoLabColorSpace::colorSpaceId(), profile);
+            d->lab16sLAB = d->colorSpace1(KoLabColorSpace::colorSpaceId());
         }
         Q_ASSERT(d->lab16sLAB);
         return d->lab16sLAB;
     }
-    return colorSpace(KoLabColorSpace::colorSpaceId(), profile);
+    return d->colorSpace1(KoLabColorSpace::colorSpaceId(), profile);
 }
 
 QList<KoID> KoColorSpaceRegistry::colorModelsList(ColorSpaceListVisibility option) const
 {
     QReadLocker l(&d->registrylock);
+
     QList<KoID> ids;
     QList<KoColorSpaceFactory*> factories = d->colorSpaceFactoryRegistry.values();
     Q_FOREACH (KoColorSpaceFactory* factory, factories) {
         if (!ids.contains(factory->colorModelId())
                 && (option == AllColorSpaces || factory->userVisible())) {
             ids << factory->colorModelId();
         }
     }
     return ids;
 }
 QList<KoID> KoColorSpaceRegistry::colorDepthList(const KoID& colorModelId, ColorSpaceListVisibility option) const
 {
     return colorDepthList(colorModelId.id(), option);
 }
 
 
 QList<KoID> KoColorSpaceRegistry::colorDepthList(const QString & colorModelId, ColorSpaceListVisibility option) const
 {
     QReadLocker l(&d->registrylock);
+
     QList<KoID> ids;
     QList<KoColorSpaceFactory*> factories = d->colorSpaceFactoryRegistry.values();
     Q_FOREACH (KoColorSpaceFactory* factory, factories) {
         if (!ids.contains(KoID(factory->colorDepthId()))
                 && factory->colorModelId().id() == colorModelId
                 && (option == AllColorSpaces || factory->userVisible())) {
             ids << factory->colorDepthId();
         }
     }
     return ids;
 }
 
-QString KoColorSpaceRegistry::colorSpaceId(const QString & colorModelId, const QString & colorDepthId) const
+QString KoColorSpaceRegistry::Private::colorSpaceIdImpl(const QString & colorModelId, const QString & colorDepthId) const
 {
-    QReadLocker l(&d->registrylock);
-    QList<KoColorSpaceFactory*> factories = d->colorSpaceFactoryRegistry.values();
+    QList<KoColorSpaceFactory*> factories = colorSpaceFactoryRegistry.values();
     Q_FOREACH (KoColorSpaceFactory* factory, factories) {
         if (factory->colorModelId().id() == colorModelId && factory->colorDepthId().id() == colorDepthId) {
             return factory->id();
         }
     }
     return "";
 }
 
+QString KoColorSpaceRegistry::colorSpaceId(const QString & colorModelId, const QString & colorDepthId) const
+{
+    QReadLocker l(&d->registrylock);
+    return d->colorSpaceIdImpl(colorModelId, colorDepthId);
+}
+
 QString KoColorSpaceRegistry::colorSpaceId(const KoID& colorModelId, const KoID& colorDepthId) const
 {
     return colorSpaceId(colorModelId.id(), colorDepthId.id());
 }
 
 KoID KoColorSpaceRegistry::colorSpaceColorModelId(const QString & _colorSpaceId) const
 {
     QReadLocker l(&d->registrylock);
+
     KoColorSpaceFactory* factory = d->colorSpaceFactoryRegistry.get(_colorSpaceId);
     if (factory) {
         return factory->colorModelId();
     } else {
         return KoID();
     }
 }
 
 KoID KoColorSpaceRegistry::colorSpaceColorDepthId(const QString & _colorSpaceId) const
 {
     QReadLocker l(&d->registrylock);
+
     KoColorSpaceFactory* factory = d->colorSpaceFactoryRegistry.get(_colorSpaceId);
     if (factory) {
         return factory->colorDepthId();
     } else {
         return KoID();
     }
 }
 
 const KoColorConversionSystem* KoColorSpaceRegistry::colorConversionSystem() const
 {
     return d->colorConversionSystem;
 }
 
 KoColorConversionCache* KoColorSpaceRegistry::colorConversionCache() const
 {
     return d->colorConversionCache;
 }
 
 const KoColorSpace* KoColorSpaceRegistry::permanentColorspace(const KoColorSpace* _colorSpace)
 {
     if (_colorSpace->d->deletability != NotOwnedByRegistry) {
         return _colorSpace;
     } else if (*_colorSpace == *d->alphaCs) {
         return d->alphaCs;
     } else {
-        const KoColorSpace* cs = colorSpace(_colorSpace->id(), _colorSpace->profile());
+        const KoColorSpace* cs = d->colorSpace1(_colorSpace->id(), _colorSpace->profile());
         Q_ASSERT(cs);
         Q_ASSERT(*cs == *_colorSpace);
         return cs;
     }
 }
 
 QList<KoID> KoColorSpaceRegistry::listKeys() const
 {
     QReadLocker l(&d->registrylock);
     QList<KoID> answer;
     Q_FOREACH (const QString& key, d->colorSpaceFactoryRegistry.keys()) {
         answer.append(KoID(key, d->colorSpaceFactoryRegistry.get(key)->name()));
     }
 
     return answer;
 }
 
+struct KoColorSpaceRegistry::Private::ProfileRegistrationInterface : public KoColorSpaceFactory::ProfileRegistrationInterface
+{
+    ProfileRegistrationInterface(KoColorSpaceRegistry::Private *_d) : d(_d) {}
+
+    const KoColorProfile* profileByName(const QString &profileName) const override {
+        return d->profileStorage.profileByName(profileName);
+    }
+
+    void registerNewProfile(KoColorProfile *profile) override {
+        d->profileStorage.addProfile(profile);
+        d->colorConversionSystem->insertColorProfile(profile);
+    }
+
+    KoColorSpaceRegistry::Private *d;
+};
+
 const KoColorProfile* KoColorSpaceRegistry::createColorProfile(const QString& colorModelId, const QString& colorDepthId, const QByteArray& rawData)
 {
-    QReadLocker l(&d->registrylock);
-    KoColorSpaceFactory* factory_ = d->colorSpaceFactoryRegistry.get(colorSpaceId(colorModelId, colorDepthId));
-    return factory_->colorProfile(rawData);
+    QWriteLocker l(&d->registrylock);
+    KoColorSpaceFactory* factory_ = d->colorSpaceFactoryRegistry.get(d->colorSpaceIdImpl(colorModelId, colorDepthId));
+
+    Private::ProfileRegistrationInterface interface(d);
+    return factory_->colorProfile(rawData, &interface);
 }
 
 QList<const KoColorSpace*> KoColorSpaceRegistry::allColorSpaces(ColorSpaceListVisibility visibility, ColorSpaceListProfilesSelection pSelection)
 {
     QList<const KoColorSpace*> colorSpaces;
 
+    // TODO: thread-unsafe code: the factories might change right after the lock in released
+    // HINT: used in a unittest only!
+
     d->registrylock.lockForRead();
     QList<KoColorSpaceFactory*> factories = d->colorSpaceFactoryRegistry.values();
     d->registrylock.unlock();
 
     Q_FOREACH (KoColorSpaceFactory* factory, factories) {
         // Don't test with ycbcr for now, since we don't have a default profile for it.
         if (factory->colorModelId().id().startsWith("Y")) continue;
         if (visibility == AllColorSpaces || factory->userVisible()) {
             if (pSelection == OnlyDefaultProfile) {
-                const KoColorSpace *cs = colorSpace(factory->id());
+                const KoColorSpace *cs = d->colorSpace1(factory->id());
                 if (cs) {
                     colorSpaces.append(cs);
                 }
                 else {
                     warnPigment << "Could not create colorspace for id" << factory->id() << "since there is no working default profile";
                 }
             } else {
                 QList<const KoColorProfile*> profiles = KoColorSpaceRegistry::instance()->profilesFor(factory->id());
                 Q_FOREACH (const KoColorProfile * profile, profiles) {
-                    const KoColorSpace *cs = colorSpace(factory->id(), profile);
+                    const KoColorSpace *cs = d->colorSpace1(factory->id(), profile);
                     if (cs) {
                         colorSpaces.append(cs);
                     }
                     else {
                         warnPigment << "Could not create colorspace for id" << factory->id() << "and profile" << profile->name();
                     }
                 }
             }
         }
     }
 
     return colorSpaces;
 }
diff --git a/libs/pigment/KoColorSpaceRegistry.h b/libs/pigment/KoColorSpaceRegistry.h
index 1504102427..d606961d0d 100644
--- a/libs/pigment/KoColorSpaceRegistry.h
+++ b/libs/pigment/KoColorSpaceRegistry.h
@@ -1,371 +1,344 @@
 /*
  *  Copyright (c) 2003 Patrick Julien  <freak@codepimps.org>
  *  Copyright (c) 2004,2010 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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.
 */
 
 #ifndef KOCOLORSPACEREGISTRY_H
 #define KOCOLORSPACEREGISTRY_H
 
 #include <QObject>
 #include <QList>
 #include <QString>
 #include "kritapigment_export.h"
 
 #include <KoGenericRegistry.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceFactory.h>
 
 class KoColorProfile;
 class KoColorConversionSystem;
 class KoColorConversionCache;
+class KoColorConversionTransformation;
 
 /**
  * The registry for colorspaces and profiles.
  * This class contains:
  *      - a registry of colorspace instantiated with specific profiles.
  *      - a registry of singleton colorspace factories.
  *      - a registry of icc profiles
  */
 class KRITAPIGMENT_EXPORT KoColorSpaceRegistry
 {
 public:
     KoColorSpaceRegistry();
 
     enum ColorSpaceListVisibility {
         OnlyUserVisible = 1, ///< Only user visible color space
         AllColorSpaces = 4 ///< All color space even those not visible to the user
     };
     enum ColorSpaceListProfilesSelection {
         OnlyDefaultProfile = 1, ///< Only add the default profile
         AllProfiles = 4 ///< Add all profiles
     };
 
     /**
      * Return an instance of the KoColorSpaceRegistry
      * Creates an instance if that has never happened before and returns the singleton instance.
      */
     static KoColorSpaceRegistry * instance();
 
     virtual ~KoColorSpaceRegistry();
 
 public:
     /**
       * add a color space to the registry
       * @param item the color space factory to add
       */
     void add(KoColorSpaceFactory* item);
 
     /**
      * Remove a color space factory from the registry. Note that it is the
      * responsibility of the caller to ensure that the colorspaces are not
      * used anymore.
      */
     void remove(KoColorSpaceFactory* item);
 
     /**
      * Add a profile to the profile map but do not add it to the
      * color conversion system yet.
      * @param profile the new profile to be registered.
      */
     void addProfileToMap(KoColorProfile *p);
 
     /**
      * register the profile with the color space registry
      * @param profile the new profile to be registered so it can be combined with
      *  colorspaces.
      */
     void addProfile(KoColorProfile* profile);
     void addProfile(const KoColorProfile* profile); // TODO why ?
     void removeProfile(KoColorProfile* profile);
 
     /**
      * Create an alias to a profile with a different name. Then @ref profileByName
      * will return the profile @p to when passed @p name as a parameter.
      */
     void addProfileAlias(const QString& name, const QString& to);
 
     /**
      * @return the profile alias, or name if not aliased
      */
     QString profileAlias(const QString& name) const;
 
     /**
      * create a profile of the specified type.
      */
     const KoColorProfile *createColorProfile(const QString & colorModelId, const QString & colorDepthId, const QByteArray& rawData);
 
     /**
      * Return a profile by its given name, or 0 if none registered.
      * @return a profile by its given name, or 0 if none registered.
      * @param name the product name as set on the profile.
      * @see addProfile()
      * @see KoColorProfile::productName()
      */
     const KoColorProfile * profileByName(const QString & name) const ;
 
 
     /**
      * Returns a profile by its unique id stored/calculated in the header.
      * The first call to this function might take long, because the map is
      * created on the first use only (atm used by SVG only)
      * @param id unique ProfileID of the profile (MD5 sum of its header)
      * @return the profile or 0 if not found
      */
     const KoColorProfile *profileByUniqueId(const QByteArray &id) const;
 
-    /**
-     * Return the list of profiles for the argument colorspacefactory.
-     * Profiles will not work with any color space, you can query which profiles
-     * that are registered with this registry can be used in combination with the
-     * argument factory.
-     * @param factory the factory with which all the returned profiles will work.
-     * @return a list of profiles for the factory
-     */
-    QList<const KoColorProfile *>  profilesFor(const KoColorSpaceFactory * factory) const;
-
-    /**
-     * Return the list of profiles for a colorspace with the argument id.
-     * Profiles will not work with any color space, you can query which profiles
-     * that are registered with this registry can be used in combination with the
-     * argument factory.
-     * @param id the colorspace-id with which all the returned profiles will work.
-     * @return a list of profiles for the factory
-     */
-    QList<const KoColorProfile *>  profilesFor(const KoID& id) const;
-
-    /**
-     * @return a list of color spaces compatible with this profile
-     */
-    QList<const KoColorSpaceFactory*> colorSpacesFor(const KoColorProfile* _profile) const;
+    bool profileIsCompatible(const KoColorProfile* profile, const QString &colorSpaceId);
 
     /**
      * Return the list of profiles for a colorspace with the argument id.
      * Profiles will not work with any color space, you can query which profiles
      * that are registered with this registry can be used in combination with the
      * argument factory.
      * @param colorSpaceId the colorspace-id with which all the returned profiles will work.
      * @return a list of profiles for the factory
      */
-    QList<const KoColorProfile *>  profilesFor(const QString& id) const;
-    const KoColorSpaceFactory* colorSpaceFactory(const QString &colorSpaceId) const;
+    QList<const KoColorProfile *>  profilesFor(const QString& csID) const;
+    QString defaultProfileForColorSpace(const QString &colorSpaceId) const;
 
-private:
     /**
-     * Return a colorspace that works with the parameter profile.
-     * @param csID the ID of the colorspace that you want to have returned
-     * @param profileName the name of the KoColorProfile to be combined with the colorspace
-     * @return the wanted colorspace, or 0 when the cs and profile can not be combined.
+     * This function is called by the color space to create a color conversion
+     * between two color space. This function search in the graph of transformations
+     * the best possible path between the two color space.
      */
-    const KoColorSpace *  colorSpace(const KoID &csID, const QString & profileName);
+    KoColorConversionTransformation* createColorConverter(const KoColorSpace * srcColorSpace, const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const;
 
     /**
-     * Return a colorspace that works with the parameter profile.
-     * @param colorSpaceId the ID string of the colorspace that you want to have returned
-     * @param profile the profile be combined with the colorspace
-     * @return the wanted colorspace, or 0 when the cs and profile can not be combined.
+     * This function creates two transformations, one from the color space and one to the
+     * color space. The destination color space is picked from a list of color space, such
+     * as the conversion between the two color space is of the best quality.
+     *
+     * The typical use case of this function is for KoColorTransformationFactory which
+     * doesn't support all color spaces, so unsupported color space have to find an
+     * acceptable conversion in order to use that KoColorTransformationFactory.
+     *
+     * @param colorSpace the source color space
+     * @param possibilities a list of color space among which we need to find the best
+     *                      conversion
+     * @param fromCS the conversion from the source color space will be affected to this
+     *               variable
+     * @param toCS the revert conversion to the source color space will be affected to this
+     *             variable
      */
-    const KoColorSpace * colorSpace(const QString &colorSpaceId, const KoColorProfile *profile);
+    void createColorConverters(const KoColorSpace* colorSpace, const QList< QPair<KoID, KoID> >& possibilities, KoColorConversionTransformation*& fromCS, KoColorConversionTransformation*& toCS) const;
 
-    /**
-     * Return a colorspace that works with the parameter profile.
-     * @param profileName the name of the KoColorProfile to be combined with the colorspace
-     * @return the wanted colorspace, or 0 when the cs and profile can not be combined.
-     */
-    const KoColorSpace * colorSpace(const QString &colorSpaceId, const QString &profileName = QString());
-public:
     /**
      * Return a colorspace that works with the parameter profile.
      * @param colorSpaceId the ID string of the colorspace that you want to have returned
      * @param profile the profile be combined with the colorspace
      * @return the wanted colorspace, or 0 when the cs and profile can not be combined.
      */
     const KoColorSpace * colorSpace(const QString & colorModelId, const QString & colorDepthId, const KoColorProfile *profile);
 
     /**
      * Return a colorspace that works with the parameter profile.
      * @param profileName the name of the KoColorProfile to be combined with the colorspace
      * @return the wanted colorspace, or 0 when the cs and profile can not be combined.
      */
     const KoColorSpace * colorSpace(const QString & colorModelId, const QString & colorDepthId, const QString &profileName);
 
+    const KoColorSpace * colorSpace(const QString & colorModelId, const QString & colorDepthId);
+
     /**
      * Return the id of the colorspace that have the defined colorModelId with colorDepthId.
      * @param colorModelId id of the color model
      * @param colorDepthId id of the color depth
      * @return the id of the wanted colorspace, or "" if no colorspace correspond to those ids
      */
     QString colorSpaceId(const QString & colorModelId, const QString & colorDepthId) const;
     /**
      * It's a convenient function that behave like the above.
      * Return the id of the colorspace that have the defined colorModelId with colorDepthId.
      * @param colorModelId id of the color model
      * @param colorDepthId id of the color depth
      * @return the id of the wanted colorspace, or "" if no colorspace correspond to those ids
      */
     QString colorSpaceId(const KoID& colorModelId, const KoID& colorDepthId) const;
 
     /**
      * @return a the identifiant of the color model for the given color space id.
      *
      * This function is a compatibility function used to get the color space from
      * all kra files.
      */
     KoID colorSpaceColorModelId(const QString & _colorSpaceId) const;
 
     /**
      * @return a the identifiant of the color depth for the given color space id.
      *
      * This function is a compatibility function used to get the color space from
      * all kra files.
      */
     KoID colorSpaceColorDepthId(const QString & _colorSpaceId) const;
 
     /**
      * Convenience methods to get the often used alpha colorspaces
      */
     const KoColorSpace *alpha8();
     const KoColorSpace *alpha16();
 #include <KoConfig.h>
 #ifdef HAVE_OPENEXR
     const KoColorSpace *alpha16f();
 #endif
     const KoColorSpace *alpha32f();
 
     /**
      * Convenience method to get an RGBA 8bit colorspace. If a profile is not specified,
      * an sRGB profile will be used.
      * @param profileName the name of an RGB color profile
      * @return the wanted colorspace, or 0 if the color space and profile can not be combined.
      */
     const KoColorSpace * rgb8(const QString &profileName = QString());
 
     /**
      * Convenience method to get an RGBA 8bit colorspace with the given profile.
      * @param profile an RGB profile
      * @return the wanted colorspace, or 0 if the color space and profile can not be combined.
      */
     const KoColorSpace * rgb8(const KoColorProfile * profile);
 
     /**
      * Convenience method to get an RGBA 16bit colorspace. If a profile is not specified,
      * an sRGB profile will be used.
      * @param profileName the name of an RGB color profile
      * @return the wanted colorspace, or 0 if the color space and profile can not be combined.
      */
     const KoColorSpace * rgb16(const QString &profileName = QString());
 
     /**
      * Convenience method to get an RGBA 16bit colorspace with the given profile.
      * @param profile an RGB profile
      * @return the wanted colorspace, or 0 if the color space and profile can not be combined.
      */
     const KoColorSpace * rgb16(const KoColorProfile * profile);
 
     /**
      * Convenience method to get an Lab 16bit colorspace. If a profile is not specified,
      * an Lab profile with a D50 whitepoint will be used.
      * @param profileName the name of an Lab color profile
      * @return the wanted colorspace, or 0 if the color space and profile can not be combined.
      */
     const KoColorSpace * lab16(const QString &profileName = QString());
 
     /**
      * Convenience method to get an Lab 16bit colorspace with the given profile.
      * @param profile an Lab profile
      * @return the wanted colorspace, or 0 if the color space and profile can not be combined.
      */
     const KoColorSpace * lab16(const KoColorProfile * profile);
 
     /**
      * @return the list of available color models
      */
     QList<KoID> colorModelsList(ColorSpaceListVisibility option) const;
 
     /**
      * @return the list of available color models for the given colorModelId
      */
     QList<KoID> colorDepthList(const KoID& colorModelId, ColorSpaceListVisibility option) const;
 
     /**
      * @return the list of available color models for the given colorModelId
      */
     QList<KoID> colorDepthList(const QString & colorModelId, ColorSpaceListVisibility option) const;
 
-    /**
-     * @return the color conversion system use by the registry and the color
-     * spaces to create color conversion transformation
-     */
-    const KoColorConversionSystem* colorConversionSystem() const;
-
     /**
      * @return the cache of color conversion transformation to be use by KoColorSpace
      */
     KoColorConversionCache* colorConversionCache() const;
 
     /**
      * @return a permanent colorspace owned by the registry, of the same type and profile
      *         as the one given in argument
      */
     const KoColorSpace* permanentColorspace(const KoColorSpace* _colorSpace);
 
     /**
      * This function return a list of all the keys in KoID format by using the name() method
      * on the objects stored in the registry.
      */
     QList<KoID> listKeys() const;
 
 private:
 
     friend class KisCsConversionTest;
     friend class KisIteratorTest;
     friend class KisPainterTest;
     friend class KisCrashFilterTest;
     friend class KoColorSpacesBenchmark;
     friend class TestKoColorSpaceSanity;
     friend class KisActionRecorderTest;
+    friend class TestColorConversionSystem;
+    friend class FriendOfColorSpaceRegistry;
+
     /**
      * @return a list with an instance of all color space with their default profile.
      */
     QList<const KoColorSpace*> allColorSpaces(ColorSpaceListVisibility visibility, ColorSpaceListProfilesSelection pSelection);
 
-private:
-
     /**
-     * The function checks if a colorspace with a certain id and profile name can be found in the cache
-     * NOTE: the function doesn't take any lock but it needs to be called inside a d->registryLock
-     * locked either in read or write.
-     * @param csId The colorspace id
-     * @param profileName The colorspace profile name
-     * @retval KoColorSpace The matching colorspace
-     * @retval 0 Null pointer if not match
+     * @return the color conversion system use by the registry and the color
+     * spaces to create color conversion transformation.
+     *
+     * WARNING: conversion system is guared by the registry locks, don't
+     *          use it anywhere other than unttests!
      */
-    const KoColorSpace* getCachedColorSpace(const QString & csId, const QString & profileName) const;
-
-    QString idsToCacheName(const QString & csId, const QString & profileName) const;
+    const KoColorConversionSystem* colorConversionSystem() const;
 
 private:
     KoColorSpaceRegistry(const KoColorSpaceRegistry&);
     KoColorSpaceRegistry operator=(const KoColorSpaceRegistry&);
     void init();
 
 private:
     struct Private;
     Private * const d;
 };
 
 #endif // KOCOLORSPACEREGISTRY_H
diff --git a/libs/pigment/tests/CCSGraph.cpp b/libs/pigment/tests/CCSGraph.cpp
index 81019a111e..a1f57ca2f2 100644
--- a/libs/pigment/tests/CCSGraph.cpp
+++ b/libs/pigment/tests/CCSGraph.cpp
@@ -1,109 +1,119 @@
 /*
  *  Copyright (c) 2007-2008 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser 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 <QFile>
 #include <QProcess>
 #include <QTemporaryFile>
 #include <QCoreApplication>
 
 #include <DebugPigment.h>
 
 #include "KoColorSpaceRegistry.h"
 #include "KoColorConversionSystem.h"
 
 #include <iostream>
 #include <QCommandLineParser>
 #include <QCommandLineOption>
 
+struct FriendOfColorSpaceRegistry {
+static QString toDot() {
+    return KoColorSpaceRegistry::instance()->colorConversionSystem()->toDot();
+}
+
+static QString bestPathToDot(const QString &srcKey, const QString &dstKey) {
+    return KoColorSpaceRegistry::instance()->colorConversionSystem()->bestPathToDot(srcKey, dstKey);
+}
+};
+
 int main(int argc, char** argv)
 {
 
     QCoreApplication app(argc, argv);
 
     QCommandLineParser parser;
 
     parser.addVersionOption();
     parser.addHelpOption();
     // Initialize the list of options
     parser.addOption(QCommandLineOption(QStringList() << QLatin1String("graphs"), i18n("return the list of available graphs")));
     parser.addOption(QCommandLineOption(QStringList() << QLatin1String("graph"), i18n("specify the type of graph (see --graphs to get the full list, the default is full)"), QLatin1String("type"), QLatin1String("full")));
     parser.addOption(QCommandLineOption(QStringList() << QLatin1String("key"), i18n("specify the key of the source color space"), QLatin1String("key"), QString()));
     parser.addOption(QCommandLineOption(QStringList() << QLatin1String("key"), i18n("specify the key of the destination color space"), QLatin1String("key"), QString()));
     parser.addOption(QCommandLineOption(QStringList() << QLatin1String("output"), i18n("specify the output (can be ps or dot, the default is ps)"), QLatin1String("type"), QLatin1String("ps")));
     parser.addPositionalArgument(QLatin1String("outputfile"), i18n("name of the output file"));
     parser.process(app); // PORTING SCRIPT: move this to after any parser.addOption
 
     if (parser.isSet("graphs")) {
         // Don't change those lines to use dbgPigment derivatives, they need to be outputed
         // to stdout not stderr.
         std::cout << "full : show all the connection on the graph" << std::endl;
         std::cout << "bestpath : show the best path for a given transformation" << std::endl;
         exit(EXIT_SUCCESS);
     }
     QString graphType = parser.value("graph");
     QString outputType = parser.value("output");
     if (parser.positionalArguments().count() != 1) {
         errorPigment << "No output file name specified";
         parser.showHelp();
         exit(EXIT_FAILURE);
     }
     QString outputFileName = parser.positionalArguments()[0];
     // Generate the graph
 
     QString dot;
     if (graphType == "full") {
-        dot = KoColorSpaceRegistry::instance()->colorConversionSystem()->toDot();
+        dot = FriendOfColorSpaceRegistry::toDot();
     } else if (graphType == "bestpath") {
         QString srcKey = parser.value("src-key");
         QString dstKey = parser.value("dst-key");
         if (srcKey.isEmpty() || dstKey.isEmpty()) {
             errorPigment << "src-key and dst-key must be specified for the graph bestpath";
             exit(EXIT_FAILURE);
         } else {
-            dot = KoColorSpaceRegistry::instance()->colorConversionSystem()->bestPathToDot(srcKey, dstKey);
+            dot = FriendOfColorSpaceRegistry::bestPathToDot(srcKey, dstKey);
         }
     } else {
         errorPigment << "Unknow graph type : " << graphType.toLatin1();
         exit(EXIT_FAILURE);
     }
 
     if (outputType == "dot") {
         QFile file(outputFileName);
         if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
             exit(EXIT_FAILURE);
         QTextStream out(&file);
         out << dot;
     } else if (outputType == "ps" || outputType == "svg") {
         QTemporaryFile file;
         if (!file.open()) {
             exit(EXIT_FAILURE);
         }
         QTextStream out(&file);
         out << dot;
         QString cmd = QString("dot -T%1 %2 -o %3").arg(outputType).arg(file.fileName()).arg(outputFileName);
         file.close();
 
         if (QProcess::execute(cmd) != 0) {
             errorPigment << "An error has occurred when executing : '" << cmd << "' the most likely cause is that 'dot' command is missing, and that you should install graphviz (from http://www.graphiz.org)";
         }
     } else {
         errorPigment << "Unknow output type : " << outputType;
         exit(EXIT_FAILURE);
     }
 }
diff --git a/libs/ui/dialogs/kis_dlg_png_import.cpp b/libs/ui/dialogs/kis_dlg_png_import.cpp
index 0b9c5de286..b976b60090 100644
--- a/libs/ui/dialogs/kis_dlg_png_import.cpp
+++ b/libs/ui/dialogs/kis_dlg_png_import.cpp
@@ -1,67 +1,64 @@
 /*
  * Copyright (C) 2015 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 "kis_dlg_png_import.h"
 
 #include <QLabel>
 
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoID.h>
 #include "widgets/squeezedcombobox.h"
 #include "kis_config.h"
 
 KisDlgPngImport::KisDlgPngImport(const QString &path, const QString &colorModelID, const QString &colorDepthID, QWidget *parent)
     : KoDialog(parent)
 {
     setButtons(Ok);
     setDefaultButton(Ok);
     QWidget *page = new QWidget(this);
     dlgWidget.setupUi(page);
     setMainWidget(page);
 
     dlgWidget.lblFilename->setText(path);
 
-    QString s = KoColorSpaceRegistry::instance()->colorSpaceId(colorModelID, colorDepthID);
+    const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(colorModelID, colorDepthID);
     dlgWidget.cmbProfile->clear();
-    const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
-    if (csf) {
-        QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
-        QStringList profileNames;
-        Q_FOREACH (const KoColorProfile *profile, profileList) {
-            profileNames.append(profile->name());
-        }
-        qSort(profileNames);
-        Q_FOREACH (QString stringName, profileNames) {
-            dlgWidget.cmbProfile->addSqueezedItem(stringName);
-        }
-        KisConfig cfg;
-        QString profile = cfg.readEntry<QString>("pngImportProfile", csf->defaultProfile());
-        dlgWidget.cmbProfile->setCurrent(profile);
+    QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId);
+    QStringList profileNames;
+    Q_FOREACH (const KoColorProfile *profile, profileList) {
+        profileNames.append(profile->name());
     }
+    qSort(profileNames);
+    Q_FOREACH (QString stringName, profileNames) {
+        dlgWidget.cmbProfile->addSqueezedItem(stringName);
+    }
+    KisConfig cfg;
+    QString profile = cfg.readEntry<QString>("pngImportProfile", KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId));
+    dlgWidget.cmbProfile->setCurrent(profile);
 }
 
 QString KisDlgPngImport::profile() const
 {
     QString p = dlgWidget.cmbProfile->itemHighlighted();
     KisConfig cfg;
     cfg.writeEntry("pngImportProfile", p);
     return p;
 }
diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index 4b72ddc9d1..5cac7e5ea1 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1128 +1,1123 @@
 /*
  *  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 <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 <QDesktopServices>
 #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 <kundo2stack.h>
 #include <KoResourcePaths.h>
 #include "kis_action_registry.h"
 
 #include "widgets/squeezedcombobox.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 "input/config/kis_input_configuration_page.h"
 
 
 GeneralTab::GeneralTab(QWidget *_parent, const char *_name)
     : WdgGeneralSettings(_parent, _name)
 {
     KisConfig cfg;
 
     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_cmbOutlineShape->addItem(i18n("No Outline"));
     m_cmbOutlineShape->addItem(i18n("Circle Outline"));
     m_cmbOutlineShape->addItem(i18n("Preview Outline"));
     m_cmbOutlineShape->addItem(i18n("Tilt Outline"));
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle());
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle());
 
     chkShowRootLayer->setChecked(cfg.showRootLayer());
 
     int autosaveInterval = cfg.autoSaveInterval();
     //convert to minutes
     m_autosaveSpinBox->setValue(autosaveInterval / 60);
     m_autosaveCheckBox->setChecked(autosaveInterval > 0);
     m_undoStackSize->setValue(cfg.undoStackLimit());
     m_backupFileCheckBox->setChecked(cfg.backupFile());
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting());
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen());
 
     KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
     m_chkNativeFileDialog->setChecked(!group.readEntry("DontUseNativeFileDialog", true));
 
     intMaxBrushSize->setValue(cfg.readEntry("maximumBrushSize", 1000));
 
     m_cmbMDIType->setCurrentIndex(cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView));
     m_chkRubberBand->setChecked(cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets());
     KoColor mdiColor;
     mdiColor.fromQColor(cfg.getMDIBackgroundColor());
     m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage());
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages());
     m_chkCompressKra->setChecked(cfg.compressKra());
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     m_chkHiDPI->setChecked(kritarc.value("EnableHiDPI", false).toBool());
     m_chkSingleApplication->setChecked(kritarc.value("EnableSingleApplication", true).toBool());
 
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker());
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt());
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport());
     m_chkCacheAnimatioInBackground->setChecked(cfg.calculateAnimationCacheInBackground());
 
     connect(m_bnFileName, SIGNAL(clicked()), SLOT(getBackgroundImage()));
     connect(clearBgImageButton, SIGNAL(clicked()), SLOT(clearBackgroundImage()));
 }
 
 void GeneralTab::setDefault()
 {
     KisConfig cfg;
 
     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);
     m_undoStackSize->setValue(cfg.undoStackLimit(true));
     m_backupFileCheckBox->setChecked(cfg.backupFile(true));
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting(true));
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen(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.fromQColor(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));
     m_chkHiDPI->setChecked(false);
     m_chkSingleApplication->setChecked(true);
 
     m_chkHiDPI->setChecked(true);
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker(true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt(true));
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport(true));
     m_chkCacheAnimatioInBackground->setChecked(cfg.calculateAnimationCacheInBackground(true));
 
 }
 
 CursorStyle GeneralTab::cursorStyle()
 {
     return (CursorStyle)m_cmbCursorShape->currentIndex();
 }
 
 OutlineStyle GeneralTab::outlineStyle()
 {
     return (OutlineStyle)m_cmbOutlineShape->currentIndex();
 }
 
 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();
 }
 
 bool GeneralTab::hideSplashScreen()
 {
     return m_hideSplashScreen->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::toolOptionsInDocker()
 {
     return m_radioToolOptionsInDocker->isChecked();
 }
 
 bool GeneralTab::switchSelectionCtrlAlt()
 {
     return m_chkSwitchSelectionCtrlAlt->isChecked();
 
 }
 
 bool GeneralTab::convertToImageColorspaceOnImport()
 {
     return m_chkConvertOnImport->isChecked();
 }
 
 bool GeneralTab::calculateAnimationCacheInBackground()
 {
     return m_chkCacheAnimatioInBackground->isChecked();
 }
 
 
 void GeneralTab::getBackgroundImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BackgroundImages");
     dialog.setCaption(i18n("Select a Background Image"));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::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;
 
     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;
         SqueezedComboBox *cmb = new SqueezedComboBox();
         cmb->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
         monitorProfileGrid->addRow(lbl, cmb);
         m_monitorProfileWidgets << cmb;
     }
 
     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());
 
     KisImageConfig cfgImage;
 
     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(QDesktopServices::storageLocation(QDesktopServices::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;
     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)
 {
     if (useSystemProfile) {
         KisConfig cfg;
         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 {
         KisConfig cfg;
         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;
     KisImageConfig cfgImage;
     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->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 & s)
+void ColorSettingsTab::refillMonitorProfiles(const KoID & colorSpaceId)
 {
-    const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s.id());
-
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         m_monitorProfileWidgets[i]->clear();
     }
 
-    if (!csf)
-        return;
-
     QMap<QString, const KoColorProfile *>  profileList;
-    Q_FOREACH(const KoColorProfile *profile, KoColorSpaceRegistry::instance()->profilesFor(csf)) {
+    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(csf->defaultProfile());
+        m_monitorProfileWidgets[i]->setCurrent(KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId.id()));
     }
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 void TabletSettingsTab::setDefault()
 {
     KisCubicCurve curve;
     curve.fromString(DEFAULT_CURVE_STRING);
     m_page->pressureCurve->setCurve(curve);
 }
 
 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;
     KisCubicCurve curve;
     curve.fromString( cfg.pressureTabletCurve() );
 
     m_page->pressureCurve->setMaximumSize(QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
     m_page->pressureCurve->setCurve(curve);
 }
 
 
 //---------------------------------------------------------------------------------------------------
 #include "kis_acyclic_signal_connector.h"
 
 int getTotalRAM() {
     KisImageConfig cfg;
     return cfg.totalRAM();
 }
 
 int PerformanceTab::realTilesRAM()
 {
     return intMemoryLimit->value() - intPoolLimit->value();
 }
 
 PerformanceTab::PerformanceTab(QWidget *parent, const char *name)
     : WdgPerformanceSettings(parent, name)
 {
     KisImageConfig cfg;
     const int totalRAM = cfg.totalRAM();
     lblTotalMemory->setText(i18n("%1 MiB", totalRAM));
 
     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()));
 
     load(false);
 }
 
 PerformanceTab::~PerformanceTab()
 {
     qDeleteAll(m_syncs);
 }
 
 void PerformanceTab::load(bool requestDefault)
 {
     KisImageConfig cfg;
 
     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));
 
     {
         KisConfig cfg2;
         chkOpenGLLogging->setChecked(cfg2.enableOpenGLDebugging(requestDefault));
         chkDisableVectorOptimizations->setChecked(cfg2.enableAmdVectorizationWorkaround(requestDefault));
     }
 }
 
 void PerformanceTab::save()
 {
     KisImageConfig cfg;
 
     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());
 
     {
         KisConfig cfg2;
         cfg2.setEnableOpenGLDebugging(chkOpenGLLogging->isChecked());
         cfg2.setEnableAmdVectorizationWorkaround(chkDisableVectorOptimizations->isChecked());
     }
 }
 
 void PerformanceTab::selectSwapDir()
 {
     KisImageConfig cfg;
     QString swapDir = cfg.swapDir();
     swapDir = QFileDialog::getExistingDirectory(0, i18nc("@title:window", "Select a swap directory"), swapDir);
     lblSwapFileLocation->setText(swapDir);
 }
 
 //---------------------------------------------------------------------------------------------------
 
 #include "KoColor.h"
 
 DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
     : WdgDisplaySettings(parent, name)
 {
     KisConfig cfg;
 
     if (!KisOpenGL::hasOpenGL()) {
         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);
         }
     }
     if (qApp->applicationName() == "kritasketch" || qApp->applicationName() == "kritagemini") {
        grpOpenGL->setVisible(false);
        grpOpenGL->setMaximumHeight(0);
     }
 
     KoColor c;
     c.fromQColor(cfg.selectionOverlayMaskColor());
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setRange(0.0, 1.0, 2);
     sldSelectionOverlayOpacity->setSingleStep(0.05);
     sldSelectionOverlayOpacity->setValue(cfg.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)));
 }
 
 void DisplaySettingsTab::setDefault()
 {
     KisConfig cfg;
     if (!KisOpenGL::hasOpenGL()) {
         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));
 
 }
 
 void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
 {
     chkUseTextureBuffer->setEnabled(isChecked);
     chkDisableVsync->setEnabled(isChecked);
     cmbFilterMode->setEnabled(isChecked);
 }
 
 //---------------------------------------------------------------------------------------------------
 FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
 {
     KisConfig cfg;
 
     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;
     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);
     button(QDialogButtonBox::Ok)->setDefault(true);
 
     setFaceType(KPageDialog::List);
 
     // 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"));
     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"));
     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"));
 
     // Display
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Display"));
     page->setObjectName("display");
     page->setHeader(i18n("Display"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-display"));
     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"));
     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"));
     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"));
     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"));
     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"));
 
 
     QPushButton *restoreDefaultsButton = button(QDialogButtonBox::RestoreDefaults);
 
     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()));
 
 }
 
 KisDlgPreferences::~KisDlgPreferences()
 {
 }
 
 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;
         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.setHideSplashScreen(dialog->m_general->hideSplashScreen());
         cfg.setCalculateAnimationCacheInBackground(dialog->m_general->calculateAnimationCacheInBackground());
 
         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().toQColor());
         cfg.setMDIBackgroundImage(dialog->m_general->m_backgroundimage->text());
         cfg.setAutoSaveInterval(dialog->m_general->autoSaveInterval());
         cfg.setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
         cfg.setShowCanvasMessages(dialog->m_general->showCanvasMessages());
         cfg.setCompressKra(dialog->m_general->compressKra());
 
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("EnableHiDPI", dialog->m_general->m_chkHiDPI->isChecked());
         kritarc.setValue("EnableSingleApplication", dialog->m_general->m_chkSingleApplication->isChecked());
 
         cfg.setToolOptionsInDocker(dialog->m_general->toolOptionsInDocker());
         cfg.setSwitchSelectionCtrlAlt(dialog->m_general->switchSelectionCtrlAlt());
         cfg.setConvertToImageColorspaceOnImport(dialog->m_general->convertToImageColorspaceOnImport());
 
         KisPart *part = KisPart::instance();
         if (part) {
             Q_FOREACH (QPointer<KisDocument> doc, part->documents()) {
                 if (doc) {
                     doc->setAutoSaveDelay(dialog->m_general->autoSaveInterval());
                     doc->setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
                     doc->undoStack()->setUndoLimit(dialog->m_general->undoStackSize());
                 }
             }
         }
         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]->itemHighlighted(),
                                       dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
         cfg.setWorkingColorSpace(dialog->m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
 
         KisImageConfig cfgImage;
         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.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() );
 
         dialog->m_performanceSettings->save();
 
         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.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());
         cfg.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());
 
         dialog->m_authorPage->apply();
 
     }
     delete dialog;
     return baccept;
 }
 
diff --git a/libs/ui/kis_png_converter.cpp b/libs/ui/kis_png_converter.cpp
index ad18ad6a78..cca0451b49 100644
--- a/libs/ui/kis_png_converter.cpp
+++ b/libs/ui/kis_png_converter.cpp
@@ -1,1287 +1,1276 @@
 /*
  *  Copyright (c) 2005-2007 Cyrille Berger <cberger@cberger.net>
  *
  *  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_png_converter.h"
 // A big thank to Glenn Randers-Pehrson for his wonderful
 // documentation of libpng available at
 // http://www.libpng.org/pub/png/libpng-1.2.5-manual.html
 
 #ifndef PNG_MAX_UINT // Removed in libpng 1.4
 #define PNG_MAX_UINT PNG_UINT_31_MAX
 #endif
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 
 #include <limits.h>
 #include <stdio.h>
 #include <zlib.h>
 
 #include <QBuffer>
 #include <QFile>
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <QUrl>
 
 #include <KoColorSpace.h>
 #include <KoDocumentInfo.h>
 #include <KoID.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 
 #include <kis_config.h>
 #include <kis_painter.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include <metadata/kis_meta_data_store.h>
 #include <KoColorModelStandardIds.h>
 #include "dialogs/kis_dlg_png_import.h"
 #include "kis_clipboard.h"
 
 namespace
 {
 
 
 int getColorTypeforColorSpace(const KoColorSpace * cs , bool alpha)
 {
 
     QString id = cs->id();
 
     if (id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16") {
         return alpha ? PNG_COLOR_TYPE_GRAY_ALPHA : PNG_COLOR_TYPE_GRAY;
     }
     if (id == "RGBA" || id == "RGBA16") {
         return alpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB;
     }
 
     return -1;
 
 }
 
 bool colorSpaceIdSupported(const QString &id)
 {
     return id == "RGBA" || id == "RGBA16" ||
         id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16";
 }
 
 QPair<QString, QString> getColorSpaceForColorType(int color_type, int color_nb_bits)
 {
     QPair<QString, QString> r;
 
     if (color_type ==  PNG_COLOR_TYPE_PALETTE) {
         r.first = RGBAColorModelID.id();
         r.second = Integer8BitsColorDepthID.id();
     } else {
         if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
             r.first = GrayAColorModelID.id();
         } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_RGB) {
             r.first = RGBAColorModelID.id();
         }
         if (color_nb_bits == 16) {
             r.second = Integer16BitsColorDepthID.id();
         } else if (color_nb_bits <= 8) {
             r.second = Integer8BitsColorDepthID.id();
         }
     }
     return r;
 }
 
 
 void fillText(png_text* p_text, const char* key, QString& text)
 {
     p_text->compression = PNG_TEXT_COMPRESSION_zTXt;
     p_text->key = const_cast<char *>(key);
     char* textc = new char[text.length()+1];
     strcpy(textc, text.toLatin1());
     p_text->text = textc;
     p_text->text_length = text.length() + 1;
 }
 
 long formatStringList(char *string, const size_t length, const char *format, va_list operands)
 {
     int n = vsnprintf(string, length, format, operands);
 
     if (n < 0)
         string[length-1] = '\0';
 
     return((long) n);
 }
 
 long formatString(char *string, const size_t length, const char *format, ...)
 {
     long n;
 
     va_list operands;
 
     va_start(operands, format);
     n = (long) formatStringList(string, length, format, operands);
     va_end(operands);
     return(n);
 }
 
 void writeRawProfile(png_struct *ping, png_info *ping_info, QString profile_type, QByteArray profile_data)
 {
 
     png_textp      text;
 
     png_uint_32    allocated_length, description_length;
 
     const uchar hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
     dbgFile << "Writing Raw profile: type=" << profile_type << ", length=" << profile_data.length() << endl;
 
     text               = (png_textp) png_malloc(ping, (png_uint_32) sizeof(png_text));
     description_length = profile_type.length();
     allocated_length   = (png_uint_32)(profile_data.length() * 2 + (profile_data.length() >> 5) + 20 + description_length);
 
     text[0].text   = (png_charp) png_malloc(ping, allocated_length);
 
     QString key = QLatin1Literal("Raw profile type ") + profile_type.toLatin1();
     QByteArray keyData = key.toLatin1();
     text[0].key = keyData.data();
 
     uchar* sp = (uchar*)profile_data.data();
     png_charp dp = text[0].text;
     *dp++ = '\n';
 
     memcpy(dp, profile_type.toLatin1().constData(), profile_type.length());
 
     dp += description_length;
     *dp++ = '\n';
 
     formatString(dp, allocated_length - strlen(text[0].text), "%8lu ", profile_data.length());
 
     dp += 8;
 
     for (long i = 0; i < (long) profile_data.length(); i++) {
         if (i % 36 == 0)
             *dp++ = '\n';
 
         *(dp++) = (char) hex[((*sp >> 4) & 0x0f)];
         *(dp++) = (char) hex[((*sp++) & 0x0f)];
     }
 
     *dp++ = '\n';
     *dp = '\0';
     text[0].text_length = (png_size_t)(dp - text[0].text);
     text[0].compression = -1;
 
     if (text[0].text_length <= allocated_length)
         png_set_text(ping, ping_info, text, 1);
 
     png_free(ping, text[0].text);
     png_free(ping, text);
 }
 
 QByteArray png_read_raw_profile(png_textp text)
 {
     QByteArray profile;
 
     static const unsigned char unhex[103] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12,
         13, 14, 15
     };
 
     png_charp sp = text[0].text + 1;
     /* look for newline */
     while (*sp != '\n')
         sp++;
     /* look for length */
     while (*sp == '\0' || *sp == ' ' || *sp == '\n')
         sp++;
     png_uint_32 length = (png_uint_32) atol(sp);
     while (*sp != ' ' && *sp != '\n')
         sp++;
     if (length == 0) {
         return profile;
     }
     profile.resize(length);
     /* copy profile, skipping white space and column 1 "=" signs */
     unsigned char *dp = (unsigned char*)profile.data();
     png_uint_32 nibbles = length * 2;
     for (png_uint_32 i = 0; i < nibbles; i++) {
         while (*sp < '0' || (*sp > '9' && *sp < 'a') || *sp > 'f') {
             if (*sp == '\0') {
                 return QByteArray();
             }
             sp++;
         }
         if (i % 2 == 0)
             *dp = (unsigned char)(16 * unhex[(int) *sp++]);
         else
             (*dp++) += unhex[(int) *sp++];
     }
     return profile;
 }
 
 void decode_meta_data(png_textp text, KisMetaData::Store* store, QString type, int headerSize)
 {
     dbgFile << "Decoding " << type << " " << text[0].key;
     KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value(type);
     Q_ASSERT(exifIO);
 
     QByteArray rawProfile = png_read_raw_profile(text);
     if (headerSize > 0) {
         rawProfile.remove(0, headerSize);
     }
     if (rawProfile.size() > 0) {
         QBuffer buffer;
         buffer.setData(rawProfile);
         exifIO->loadFrom(store, &buffer);
     } else {
         dbgFile << "Decoding failed";
     }
 }
 }
 
 KisPNGConverter::KisPNGConverter(KisDocument *doc, bool batchMode)
 {
     //     Q_ASSERT(doc);
     //     Q_ASSERT(adapter);
 
     m_doc = doc;
     m_stop = false;
     m_max_row = 0;
     m_image = 0;
     m_batchMode = batchMode;
 }
 
 KisPNGConverter::~KisPNGConverter()
 {
 }
 
 class KisPNGReadStream
 {
 public:
     KisPNGReadStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
     }
     int nextValue() {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
         }
         m_posinc -= m_depth;
         return (((*m_buf) >> (m_posinc)) & ((1 << m_depth) - 1));
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGWriteStream
 {
 public:
     KisPNGWriteStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
         *m_buf = 0;
     }
     void setNextValue(int v) {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
             *m_buf = 0;
         }
         m_posinc -= m_depth;
         *m_buf = (v << m_posinc) | *m_buf;
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGReaderAbstract
 {
 public:
     KisPNGReaderAbstract(png_structp _png_ptr, int _width, int _height) : png_ptr(_png_ptr), width(_width), height(_height) {}
     virtual ~KisPNGReaderAbstract() {}
     virtual png_bytep readLine() = 0;
 protected:
     png_structp png_ptr;
     int width, height;
 };
 
 class KisPNGReaderLineByLine : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderLineByLine(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height) {
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         row_pointer = new png_byte[rowbytes];
     }
     ~KisPNGReaderLineByLine() override {
         delete[] row_pointer;
     }
     png_bytep readLine() override {
         png_read_row(png_ptr, row_pointer, 0);
         return row_pointer;
     }
 private:
     png_bytep row_pointer;
 };
 
 class KisPNGReaderFullImage : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderFullImage(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height), y(0) {
         row_pointers = new png_bytep[height];
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         for (int i = 0; i < height; i++) {
             row_pointers[i] = new png_byte[rowbytes];
         }
         png_read_image(png_ptr, row_pointers);
     }
     ~KisPNGReaderFullImage() override {
         for (int i = 0; i < height; i++) {
             delete[] row_pointers[i];
         }
         delete[] row_pointers;
     }
     png_bytep readLine() override {
         return row_pointers[y++];
     }
 private:
     png_bytepp row_pointers;
     int y;
 };
 
 
 static
 void _read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice *in = (QIODevice *)png_get_io_ptr(png_ptr);
 
     while (length) {
         int nr = in->read((char*)data, length);
         if (nr <= 0) {
             png_error(png_ptr, "Read Error");
             return;
         }
         length -= nr;
     }
 }
 
 static
 void _write_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice* out = (QIODevice*)png_get_io_ptr(png_ptr);
 
     uint nr = out->write((char*)data, length);
     if (nr != length) {
         png_error(png_ptr, "Write Error");
         return;
     }
 }
 
 static
 void _flush_fn(png_structp png_ptr)
 {
     Q_UNUSED(png_ptr);
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildImage(QIODevice* iod)
 {
     dbgFile << "Start decoding PNG File";
 
     png_byte signature[8];
     iod->peek((char*)signature, 8);
 
 #if PNG_LIBPNG_VER < 10400
     if (!png_check_sig(signature, 8)) {
 #else
     if (png_sig_cmp(signature, 0, 8) != 0) {
 #endif
         iod->close();
         return (KisImageBuilder_RESULT_BAD_FETCH);
     }
 
     // Initialize the internal structures
     png_structp png_ptr =  png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         iod->close();
     }
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_read_struct(&png_ptr, (png_infopp)0, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     png_infop end_info = png_create_info_struct(png_ptr);
     if (!end_info) {
         png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Catch errors
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Initialize the special
     png_set_read_fn(png_ptr, iod, _read_fn);
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
     // read all PNG info up to image data
     png_read_info(png_ptr, info_ptr);
 
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_expand(png_ptr);
     }
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_packing(png_ptr);
     }
 
 
     if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE &&
             (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) {
         png_set_expand(png_ptr);
     }
     png_read_update_info(png_ptr, info_ptr);
 
     // Read information about the png
     png_uint_32 width, height;
     int color_nb_bits, color_type, interlace_type;
     png_get_IHDR(png_ptr, info_ptr, &width, &height, &color_nb_bits, &color_type, &interlace_type, 0, 0);
     dbgFile << "width = " << width << " height = " << height << " color_nb_bits = " << color_nb_bits << " color_type = " << color_type << " interlace_type = " << interlace_type << endl;
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Determine the colorspace
     QPair<QString, QString> csName = getColorSpaceForColorType(color_type, color_nb_bits);
     if (csName.first.isEmpty()) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     bool hasalpha = (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_GRAY_ALPHA);
 
     // Read image profile
     png_charp profile_name;
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
     png_bytep profile_data;
 #else
     png_charp profile_data;
 #endif
     int compression_type;
     png_uint_32 proflen;
 
     // Get the various optional chunks
 
     // https://www.w3.org/TR/PNG/#11cHRM
 #if defined(PNG_cHRM_SUPPORTED)
     double whitePointX, whitePointY;
     double redX, redY;
     double greenX, greenY;
     double blueX, blueY;
     png_get_cHRM(png_ptr,info_ptr, &whitePointX, &whitePointY, &redX, &redY, &greenX, &greenY, &blueX, &blueY);
     qDebug() << "cHRM:" << whitePointX << whitePointY << redX << redY << greenX << greenY << blueX << blueY;
 #endif
 
     // https://www.w3.org/TR/PNG/#11gAMA
 #if defined(PNG_GAMMA_SUPPORTED)
     double gamma;
     png_get_gAMA(png_ptr, info_ptr, &gamma);
     qDebug() << "gAMA" << gamma;
 #endif
 
     // https://www.w3.org/TR/PNG/#11sRGB
 #if defined(PNG_sRGB_SUPPORTED)
     int sRGBIntent;
     png_get_sRGB(png_ptr, info_ptr, &sRGBIntent);
     qDebug() << "sRGB" << sRGBIntent;
 #endif
 
     bool fromBlender = false;
 
     png_text* text_ptr;
     int num_comments;
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
 
     for (int i = 0; i < num_comments; i++) {
         QString key = QString(text_ptr[i].key).toLower();
         if (key == "file") {
             QString relatedFile = text_ptr[i].text;
             if (relatedFile.contains(".blend", Qt::CaseInsensitive)){
                 fromBlender=true;
             }
         }
     }
 
     const KoColorProfile* profile = 0;
     if (png_get_iCCP(png_ptr, info_ptr, &profile_name, &compression_type, &profile_data, &proflen)) {
         QByteArray profile_rawdata;
         // XXX: Hardcoded for icc type -- is that correct for us?
         profile_rawdata.resize(proflen);
         memcpy(profile_rawdata.data(), profile_data, proflen);
         profile = KoColorSpaceRegistry::instance()->createColorProfile(csName.first, csName.second, profile_rawdata);
         Q_CHECK_PTR(profile);
         if (profile) {
             //                 dbgFile << "profile name: " << profile->productName() << " profile description: " << profile->productDescription() << " information sur le produit: " << profile->productInfo();
             if (!profile->isSuitableForOutput()) {
                 dbgFile << "the profile is not suitable for output and therefore cannot be used in krita, we need to convert the image to a standard profile"; // TODO: in ko2 popup a selection menu to inform the user
             }
         }
     }
     else {
         dbgFile << "no embedded profile, will use the default profile";
         if (color_nb_bits == 16 && !fromBlender && !qAppName().toLower().contains("test") && !m_batchMode) {
             KisConfig cfg;
             quint32 behaviour = cfg.pasteBehaviour();
             if (behaviour == PASTE_ASK) {
                 KisDlgPngImport dlg(m_path, csName.first, csName.second);
                 QApplication::restoreOverrideCursor();
                 dlg.exec();
                 if (!dlg.profile().isEmpty()) {
-
-                    QString s = KoColorSpaceRegistry::instance()->colorSpaceId(csName.first, csName.second);
-
-                    const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
-                    if (csf) {
-                        QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
-                        Q_FOREACH (const KoColorProfile *p, profileList) {
-                            if (p->name() == dlg.profile()) {
-                                profile = p;
-                                break;
-                            }
-                        }
-                    }
+                    profile = KoColorSpaceRegistry::instance()->profileByName(dlg.profile());
                 }
                 QApplication::setOverrideCursor(Qt::WaitCursor);
 
             }
         }
         dbgFile << "no embedded profile, will use the default profile";
     }
 
+    const QString colorSpaceId =
+        KoColorSpaceRegistry::instance()->colorSpaceId(csName.first, csName.second);
+
     // Check that the profile is used by the color space
-    if (profile && !KoColorSpaceRegistry::instance()->colorSpaceFactory(
-                KoColorSpaceRegistry::instance()->colorSpaceId(
-                    csName.first, csName.second))->profileIsCompatible(profile)) {
+    if (profile && !KoColorSpaceRegistry::instance()->profileIsCompatible(profile, colorSpaceId)) {
         warnFile << "The profile " << profile->name() << " is not compatible with the color space model " << csName.first << " " << csName.second;
         profile = 0;
     }
 
     // Retrieve a pointer to the colorspace
     const KoColorSpace* cs;
     if (profile && profile->isSuitableForOutput()) {
         dbgFile << "image has embedded profile: " << profile->name() << "\n";
         cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile);
     }
     else {
         if (csName.first == RGBAColorModelID.id()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, "sRGB-elle-V2-srgbtrc.icc");
         }
         else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, 0);
         }
     }
 
     if (cs == 0) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     //TODO: two fixes : one tell the user about the problem and ask for a solution, and two once the kocolorspace include KoColorTransformation, use that instead of hacking a lcms transformation
     // Create the cmsTransform if needed
     KoColorTransformation* transform = 0;
     if (profile && !profile->isSuitableForOutput()) {
         transform = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     }
 
     // Creating the KisImageSP
     if (m_image == 0) {
         m_image = new KisImage(m_doc->createUndoStore(), width, height, cs, "built image");
         Q_CHECK_PTR(m_image);
     }
 
     // Read resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 
     png_get_pHYs(png_ptr, info_ptr, &x_resolution, &y_resolution, &unit_type);
     if (x_resolution > 0 && y_resolution > 0 && unit_type == PNG_RESOLUTION_METER) {
         m_image->setResolution((double) POINT_TO_CM(x_resolution) / 100.0, (double) POINT_TO_CM(y_resolution) / 100.0); // It is the "invert" macro because we convert from pointer-per-inchs to points
     }
 
     double coeff = quint8_MAX / (double)(pow((double)2, color_nb_bits) - 1);
     KisPaintLayerSP layer = new KisPaintLayer(m_image.data(), m_image -> nextLayerName(), UCHAR_MAX);
 
     // Read comments/texts...
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
     if (m_doc) {
         KoDocumentInfo * info = m_doc->documentInfo();
         dbgFile << "There are " << num_comments << " comments in the text";
         for (int i = 0; i < num_comments; i++) {
             QString key = QString(text_ptr[i].key).toLower();
             dbgFile << "key is |" << text_ptr[i].key << "| containing " << text_ptr[i].text << " " << (key ==  "Raw profile type exif ");
             if (key == "title") {
                 info->setAboutInfo("title", text_ptr[i].text);
             } else if (key == "description") {
                 info->setAboutInfo("comment", text_ptr[i].text);
             } else if (key == "author") {
         qDebug()<<"Author:"<<text_ptr[i].text;
                 info->setAuthorInfo("creator", text_ptr[i].text);
             } else if (key.contains("Raw profile type exif")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "exif", 6);
             } else if (key.contains("Raw profile type iptc")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "iptc", 14);
             } else if (key.contains("Raw profile type xmp")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "xmp", 0);
             } else if (key == "version") {
                 m_image->addAnnotation(new KisAnnotation("kpp_version", "version", QByteArray(text_ptr[i].text)));
             } else if (key == "preset") {
                 m_image->addAnnotation(new KisAnnotation("kpp_preset", "preset", QByteArray(text_ptr[i].text)));
             }
         }
     }
 
     // Read image data
     KisPNGReaderAbstract* reader = 0;
     try {
         if (interlace_type == PNG_INTERLACE_ADAM7) {
             reader = new KisPNGReaderFullImage(png_ptr, info_ptr, width, height);
         } else {
             reader = new KisPNGReaderLineByLine(png_ptr, info_ptr, width, height);
         }
     } catch (std::bad_alloc& e) {
         // new png_byte[] may raise such an exception if the image
         // is invalid / to large.
         dbgFile << "bad alloc: " << e.what();
         // Free only the already allocated png_byte instances.
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Read the palette if the file is indexed
     png_colorp palette ;
     int num_palette;
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
     }
 
     // Read the transparency palette
     quint8 palette_alpha[256];
     memset(palette_alpha, 255, 256);
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
         if (color_type == PNG_COLOR_TYPE_PALETTE) {
             png_bytep alpha_ptr;
             int num_alpha;
             png_get_tRNS(png_ptr, info_ptr, &alpha_ptr, &num_alpha, 0);
             for (int i = 0; i < num_alpha; ++i) {
                 palette_alpha[i] = alpha_ptr[i];
             }
         }
     }
 
     for (png_uint_32 y = 0; y < height; y++) {
         KisHLineIteratorSP it = layer -> paintDevice() -> createHLineIteratorNG(0, y, width);
 
         png_bytep row_pointer = reader->readLine();
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8*>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) {
                         d[1] = *(src++);
                     } else {
                         d[1] = quint16_MAX;
                     }
                 } while (it->nextPixel());
             } else  {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) {
                         d[1] = (quint8)(stream.nextValue() * coeff);
                     } else {
                         d[1] = UCHAR_MAX;
                     }
                 } while (it->nextPixel());
             }
             // FIXME:should be able to read 1 and 4 bits depth and scale them to 8 bits"
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[2] = *(src++);
                     d[1] = *(src++);
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) d[3] = *(src++);
                     else d[3] = quint16_MAX;
                 } while (it->nextPixel());
             } else {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[2] = (quint8)(stream.nextValue() * coeff);
                     d[1] = (quint8)(stream.nextValue() * coeff);
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) d[3] = (quint8)(stream.nextValue() * coeff);
                     else d[3] = UCHAR_MAX;
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             KisPNGReadStream stream(row_pointer, color_nb_bits);
             do {
                 quint8 *d = it->rawData();
                 quint8 index = stream.nextValue();
                 quint8 alpha = palette_alpha[ index ];
                 if (alpha == 0) {
                     memset(d, 0, 4);
                 } else {
                     png_color c = palette[ index ];
                     d[2] = c.red;
                     d[1] = c.green;
                     d[0] = c.blue;
                     d[3] = alpha;
                 }
             } while (it->nextPixel());
         }
             break;
         default:
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
     m_image->addNode(layer.data(), m_image->rootLayer().data());
 
     png_read_end(png_ptr, end_info);
     iod->close();
 
     // Freeing memory
     png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
 
     delete reader;
     return KisImageBuilder_RESULT_OK;
 
 }
 
 KisImageBuilder_Result KisPNGConverter::buildImage(const QString &filename)
 {
     m_path = filename;
 
     QFile fp(filename);
     if (fp.exists()) {
         if (!fp.open(QIODevice::ReadOnly)) {
             dbgFile << "Failed to open PNG File";
             return (KisImageBuilder_RESULT_FAILURE);
         }
 
         return buildImage(&fp);
     }
     return (KisImageBuilder_RESULT_NOT_EXIST);
 
 }
 
 
 KisImageSP KisPNGConverter::image()
 {
     return m_image;
 }
 
 bool KisPNGConverter::saveDeviceToStore(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP dev, KoStore *store, KisMetaData::Store* metaData)
 {
     if (store->open(filename)) {
         KoStoreDevice io(store);
         if (!io.open(QIODevice::WriteOnly)) {
             dbgFile << "Could not open for writing:" << filename;
             return false;
         }
         KisPNGConverter pngconv(0);
         vKisAnnotationSP_it annotIt = 0;
         KisMetaData::Store* metaDataStore = 0;
         if (metaData) {
             metaDataStore = new KisMetaData::Store(*metaData);
         }
         KisPNGOptions options;
         options.compression = 0;
         options.interlace = false;
         options.tryToSaveAsIndexed = false;
         options.alpha = true;
         options.saveSRGBProfile = false;
 
         if (dev->colorSpace()->id() != "RGBA") {
             dev = new KisPaintDevice(*dev.data());
             KUndo2Command *cmd = dev->convertTo(KoColorSpaceRegistry::instance()->rgb8());
             delete cmd;
         }
 
         bool success = pngconv.buildFile(&io, imageRect, xRes, yRes, dev, annotIt, annotIt, options, metaDataStore);
         if (success != KisImageBuilder_RESULT_OK) {
             dbgFile << "Saving PNG failed:" << filename;
             delete metaDataStore;
             return false;
         }
         delete metaDataStore;
         io.close();
         if (!store->close()) {
             return false;
         }
     } else {
         dbgFile << "Opening of data file failed :" << filename;
         return false;
     }
     return true;
 
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildFile(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     dbgFile << "Start writing PNG File " << filename;
     // Open a QIODevice for writing
     QFile fp (filename);
     if (!fp.open(QIODevice::WriteOnly)) {
         dbgFile << "Failed to open PNG File for writing";
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     KisImageBuilder_Result result = buildFile(&fp, imageRect, xRes, yRes, device, annotationsStart, annotationsEnd, options, metaData);
 
     return result;
 }
 
 KisImageBuilder_Result KisPNGConverter::buildFile(QIODevice* iodevice, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     if (!device)
         return KisImageBuilder_RESULT_INVALID_ARG;
 
     if (!options.alpha) {
         KisPaintDeviceSP tmp = new KisPaintDevice(device->colorSpace());
         KoColor c(options.transparencyFillColor, device->colorSpace());
         tmp->fill(imageRect, c);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (device->colorSpace()->colorDepthId() == Float16BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float32BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float64BitsColorDepthID) {
         const KoColorSpace *dstcs = KoColorSpaceRegistry::instance()->colorSpace(device->colorSpace()->colorModelId().id(), Integer8BitsColorDepthID.id(), "");
         KisPaintDeviceSP tmp = new KisPaintDevice(dstcs);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (options.forceSRGB) {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), device->colorSpace()->colorDepthId().id(), "sRGB built-in - (lcms internal)");
         device = new KisPaintDevice(*device);
         KUndo2Command *cmd = device->convertTo(cs);
         delete cmd;
     }
 
     // Initialize structures
     png_structp png_ptr =  png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
 
 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
     png_set_check_for_invalid_index(png_ptr, 0);
 #endif
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_write_struct(&png_ptr, (png_infopp)0);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // If an error occurs during writing, libpng will jump here
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_write_struct(&png_ptr, &info_ptr);
         return (KisImageBuilder_RESULT_FAILURE);
     }
     // Initialize the writing
     //     png_init_io(png_ptr, fp);
     // Setup the progress function
     // XXX: Implement progress updating -- png_set_write_status_fn(png_ptr, progress);"
     //     setProgressTotalSteps(100/*height*/);
 
     /* set the zlib compression level */
     png_set_compression_level(png_ptr, options.compression);
 
     png_set_write_fn(png_ptr, (void*)iodevice, _write_fn, _flush_fn);
 
     /* set other zlib parameters */
     png_set_compression_mem_level(png_ptr, 8);
     png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
     png_set_compression_window_bits(png_ptr, 15);
     png_set_compression_method(png_ptr, 8);
     png_set_compression_buffer_size(png_ptr, 8192);
 
     int color_nb_bits = 8 * device->pixelSize() / device->channelCount();
     int color_type = getColorTypeforColorSpace(device->colorSpace(), options.alpha);
 
     Q_ASSERT(color_type > -1);
 
     // Try to compute a table of color if the colorspace is RGB8f
     png_colorp palette = 0;
     int num_palette = 0;
     if (!options.alpha && options.tryToSaveAsIndexed && KoID(device->colorSpace()->id()) == KoID("RGBA")) { // png doesn't handle indexed images and alpha, and only have indexed for RGB8
         palette = new png_color[255];
 
         KisSequentialIterator it(device, imageRect);
 
         bool toomuchcolor = false;
         do {
             const quint8* c = it.oldRawData();
             bool findit = false;
             for (int i = 0; i < num_palette; i++) {
                 if (palette[i].red == c[2] &&
                         palette[i].green == c[1] &&
                         palette[i].blue == c[0]) {
                     findit = true;
                     break;
                 }
             }
             if (!findit) {
                 if (num_palette == 255) {
                     toomuchcolor = true;
                     break;
                 }
                 palette[num_palette].red = c[2];
                 palette[num_palette].green = c[1];
                 palette[num_palette].blue = c[0];
                 num_palette++;
             }
         }  while (it.nextPixel());
 
         if (!toomuchcolor) {
             dbgFile << "Found a palette of " << num_palette << " colors";
             color_type = PNG_COLOR_TYPE_PALETTE;
             if (num_palette <= 2) {
                 color_nb_bits = 1;
             } else if (num_palette <= 4) {
                 color_nb_bits = 2;
             } else if (num_palette <= 16) {
                 color_nb_bits = 4;
             } else {
                 color_nb_bits = 8;
             }
         } else {
             delete [] palette;
         }
     }
 
     int interlacetype = options.interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
 
     png_set_IHDR(png_ptr, info_ptr,
                  imageRect.width(),
                  imageRect.height(),
                  color_nb_bits,
                  color_type, interlacetype,
                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
     // set sRGB only if the profile is sRGB  -- http://www.w3.org/TR/PNG/#11sRGB says sRGB and iCCP should not both be present
 
     bool sRGB = device->colorSpace()->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive);
     /*
      * This automatically writes the correct gamma and chroma chunks along with the sRGB chunk, but firefox's
      * color management is bugged, so once you give it any incentive to start color managing an sRGB image it
      * will turn, for example, a nice desaturated rusty red into bright poppy red. So this is disabled for now.
      */
     /*if (!options.saveSRGBProfile && sRGB) {
         png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
     }*/
     // set the palette
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
     }
     // Save annotation
     vKisAnnotationSP_it it = annotationsStart;
     while (it != annotationsEnd) {
         if (!(*it) || (*it)->type().isEmpty()) {
             dbgFile << "Warning: empty annotation";
             it++;
             continue;
         }
 
         dbgFile << "Trying to store annotation of type " << (*it) -> type() << " of size " << (*it) -> annotation() . size();
 
         if ((*it) -> type().startsWith(QString("krita_attribute:"))) { //
             // Attribute
             // XXX: it should be possible to save krita_attributes in the \"CHUNKs\""
             dbgFile << "cannot save this annotation : " << (*it) -> type();
         } else if ((*it)->type() == "kpp_version" || (*it)->type() == "kpp_preset" ) {
             dbgFile << "Saving preset information " << (*it)->description();
             png_textp      text = (png_textp) png_malloc(png_ptr, (png_uint_32) sizeof(png_text));
 
             QByteArray keyData = (*it)->description().toLatin1();
             text[0].key = keyData.data();
             text[0].text = (char*)(*it)->annotation().data();
             text[0].text_length = (*it)->annotation().size();
             text[0].compression = -1;
 
             png_set_text(png_ptr, info_ptr, text, 1);
             png_free(png_ptr, text);
         }
         it++;
     }
 
     // Save the color profile
     const KoColorProfile* colorProfile = device->colorSpace()->profile();
     QByteArray colorProfileData = colorProfile->rawData();
     if (!sRGB || options.saveSRGBProfile) {
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (const png_bytep)colorProfileData.constData(), colorProfileData . size());
 #else
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (char*)colorProfileData.constData(), colorProfileData . size());
 #endif
     }
 
     // read comments from the document information
     // warning: according to the official png spec, the keys need to be capitalised!
     if (m_doc) {
         png_text texts[3];
         int nbtexts = 0;
         KoDocumentInfo * info = m_doc->documentInfo();
         QString title = info->aboutInfo("title");
         if (!title.isEmpty()) {
             fillText(texts + nbtexts, "Title", title);
             nbtexts++;
         }
         QString abstract = info->aboutInfo("comment");
         if (!abstract.isEmpty()) {
             fillText(texts + nbtexts, "Description", abstract);
             nbtexts++;
         }
         QString author = info->authorInfo("creator");
         if (!author.isEmpty()) {
             fillText(texts + nbtexts, "Author", author);
             nbtexts++;
         }
 
         png_set_text(png_ptr, info_ptr, texts, nbtexts);
     }
 
     // Save metadata following imagemagick way
 
     // Save exif
     if (metaData && !metaData->empty()) {
         if (options.exif) {
             dbgFile << "Trying to save exif information";
 
             KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value("exif");
             Q_ASSERT(exifIO);
 
             QBuffer buffer;
             exifIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
             writeRawProfile(png_ptr, info_ptr, "exif", buffer.data());
         }
         // Save IPTC
         if (options.iptc) {
             dbgFile << "Trying to save exif information";
             KisMetaData::IOBackend* iptcIO = KisMetaData::IOBackendRegistry::instance()->value("iptc");
             Q_ASSERT(iptcIO);
 
             QBuffer buffer;
             iptcIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
 
             dbgFile << "IPTC information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "iptc", buffer.data());
         }
         // Save XMP
         if (options.xmp) {
             dbgFile << "Trying to save XMP information";
             KisMetaData::IOBackend* xmpIO = KisMetaData::IOBackendRegistry::instance()->value("xmp");
             Q_ASSERT(xmpIO);
 
             QBuffer buffer;
             xmpIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::NoHeader);
 
             dbgFile << "XMP information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "xmp", buffer.data());
         }
     }
 #if 0 // Unimplemented?
     // Save resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 #endif
     png_set_pHYs(png_ptr, info_ptr, CM_TO_POINT(xRes) * 100.0, CM_TO_POINT(yRes) * 100.0, PNG_RESOLUTION_METER); // It is the "invert" macro because we convert from pointer-per-inchs to points
 
     // Save the information to the file
     png_write_info(png_ptr, info_ptr);
     png_write_flush(png_ptr);
 
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Write the PNG
     //     png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);
 
     // Fill the data structure
     png_byte** row_pointers = new png_byte*[imageRect.height()];
     int row = 0;
     for (int y = imageRect.y(); y < imageRect.y() + imageRect.height(); y++, row++) {
         KisHLineConstIteratorSP it = device->createHLineConstIteratorNG(imageRect.x(), y, imageRect.width());
 
         row_pointers[row] = new png_byte[imageRect.width() * device->pixelSize()];
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(row_pointers[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = row_pointers[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(row_pointers[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = row_pointers[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             quint8 *dst = row_pointers[row];
             KisPNGWriteStream writestream(dst, color_nb_bits);
             do {
                 const quint8 *d = it->oldRawData();
                 int i;
                 for (i = 0; i < num_palette; i++) {
                     if (palette[i].red == d[2] &&
                             palette[i].green == d[1] &&
                             palette[i].blue == d[0]) {
                         break;
                     }
                 }
                 writestream.setNextValue(i);
             } while (it->nextPixel());
         }
             break;
         default:
             delete[] row_pointers;
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
 
     png_write_image(png_ptr, row_pointers);
 
     // Writing is over
     png_write_end(png_ptr, info_ptr);
 
     // Free memory
     png_destroy_write_struct(&png_ptr, &info_ptr);
     for (int y = 0; y < imageRect.height(); y++) {
         delete[] row_pointers[y];
     }
     delete[] row_pointers;
 
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         delete [] palette;
     }
     return KisImageBuilder_RESULT_OK;
 }
 
 
 void KisPNGConverter::cancel()
 {
     m_stop = true;
 }
 
 void KisPNGConverter::progress(png_structp png_ptr, png_uint_32 row_number, int pass)
 {
     if (png_ptr == 0 || row_number > PNG_MAX_UINT || pass > 7) return;
     //     setProgress(row_number);
 }
 
 bool KisPNGConverter::isColorSpaceSupported(const KoColorSpace *cs)
 {
     return colorSpaceIdSupported(cs->id());
 }
 
 
diff --git a/libs/ui/widgets/kis_advanced_color_space_selector.cc b/libs/ui/widgets/kis_advanced_color_space_selector.cc
index dee04ed433..1c30cad434 100644
--- a/libs/ui/widgets/kis_advanced_color_space_selector.cc
+++ b/libs/ui/widgets/kis_advanced_color_space_selector.cc
@@ -1,796 +1,793 @@
 /*
  *  Copyright (C) 2007 Cyrille Berger <cberger@cberger.net>
  *  Copyright (C) 2011 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (C) 2015 Wolthera van Hövell tot Westerflier <griffinvalley@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_advanced_color_space_selector.h"
 
 #include <KoFileDialog.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorModelStandardIds.h>
 #include <KoID.h>
 
 #include <KoConfig.h>
 #include <kis_icon.h>
 
 #include <QDesktopServices>
 #include <QTextBrowser>
 #include <QScrollBar>
 
 #include <KoResourcePaths.h>
 
 #include <QUrl>
 
 #include "ui_wdgcolorspaceselectoradvanced.h"
 
 #include <kis_debug.h>
 
 struct KisAdvancedColorSpaceSelector::Private {
     Ui_WdgColorSpaceSelectorAdvanced* colorSpaceSelector;
     QString knsrcFile;
 };
 
 KisAdvancedColorSpaceSelector::KisAdvancedColorSpaceSelector(QWidget* parent, const QString &caption)
     : QDialog(parent)
     , d(new Private)
 {
     setWindowTitle(caption);
 
     d->colorSpaceSelector = new Ui_WdgColorSpaceSelectorAdvanced;
     d->colorSpaceSelector->setupUi(this);
 
     d->colorSpaceSelector->cmbColorModels->setIDList(KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::OnlyUserVisible));
     fillCmbDepths(d->colorSpaceSelector->cmbColorModels->currentItem());
 
     d->colorSpaceSelector->bnInstallProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     d->colorSpaceSelector->bnInstallProfile->setToolTip( i18n("Open Color Profile") );
 
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(const KoID &)),
             this, SLOT(fillCmbDepths(const KoID &)));
     connect(d->colorSpaceSelector->cmbColorDepth, SIGNAL(activated(const KoID &)),
             this, SLOT(fillLstProfiles()));
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(const KoID &)),
             this, SLOT(fillLstProfiles()));
     connect(d->colorSpaceSelector->lstProfile, SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)),
             this, SLOT(colorSpaceChanged()));
     connect(this, SIGNAL(selectionChanged(bool)),
             this, SLOT(fillDescription()));
     connect(this, SIGNAL(selectionChanged(bool)), d->colorSpaceSelector->TongueWidget, SLOT(repaint()));
     connect(this, SIGNAL(selectionChanged(bool)), d->colorSpaceSelector->TRCwidget, SLOT(repaint()));
 
     connect(d->colorSpaceSelector->bnInstallProfile, SIGNAL(clicked()), this, SLOT(installProfile()));
 
     connect(d->colorSpaceSelector->bnOK, SIGNAL(accepted()), this, SLOT(accept()));
     connect(d->colorSpaceSelector->bnOK, SIGNAL(rejected()), this, SLOT(reject()));
 
     fillLstProfiles();
 }
 
 KisAdvancedColorSpaceSelector::~KisAdvancedColorSpaceSelector()
 {
     delete d->colorSpaceSelector;
     delete d;
 }
 
 void KisAdvancedColorSpaceSelector::fillLstProfiles()
 {
     d->colorSpaceSelector->lstProfile->blockSignals(true);
-    QString s = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
+    const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
+    const QString defaultProfileName = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId);
     d->colorSpaceSelector->lstProfile->clear();
 
-    const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
-    if (csf == 0) return;//TODO: make this give better feedback.
-
-    QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
+    QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId);
     QStringList profileNames;
     Q_FOREACH (const KoColorProfile *profile, profileList) {
         profileNames.append(profile->name());
     }
     qSort(profileNames);
     QListWidgetItem *defaultProfile = new QListWidgetItem;
-    defaultProfile->setText(csf->defaultProfile() + " " + i18nc("This is appended to the color profile which is the default for the given colorspace and bit-depth","(Default)"));
+    defaultProfile->setText(defaultProfileName + " " + i18nc("This is appended to the color profile which is the default for the given colorspace and bit-depth","(Default)"));
     Q_FOREACH (QString stringName, profileNames) {
-        if (stringName==csf->defaultProfile()) {
+        if (stringName == defaultProfileName) {
             d->colorSpaceSelector->lstProfile->addItem(defaultProfile);
         } else {
             d->colorSpaceSelector->lstProfile->addItem(stringName);
         }
     }
     d->colorSpaceSelector->lstProfile->setCurrentItem(defaultProfile);
     d->colorSpaceSelector->lstProfile->blockSignals(false);
     colorSpaceChanged();
 }
 
 void KisAdvancedColorSpaceSelector::fillCmbDepths(const KoID& id)
 {
     KoID activeDepth = d->colorSpaceSelector->cmbColorDepth->currentItem();
     d->colorSpaceSelector->cmbColorDepth->clear();
     QList<KoID> depths = KoColorSpaceRegistry::instance()->colorDepthList(id, KoColorSpaceRegistry::OnlyUserVisible);
     QList<KoID> sortedDepths;
     if (depths.contains(Integer8BitsColorDepthID)) {
         sortedDepths << Integer8BitsColorDepthID;
     }
     if (depths.contains(Integer16BitsColorDepthID)) {
         sortedDepths << Integer16BitsColorDepthID;
     }
     if (depths.contains(Float16BitsColorDepthID)) {
         sortedDepths << Float16BitsColorDepthID;
     }
     if (depths.contains(Float32BitsColorDepthID)) {
         sortedDepths << Float32BitsColorDepthID;
     }
     if (depths.contains(Float64BitsColorDepthID)) {
         sortedDepths << Float64BitsColorDepthID;
     }
 
     d->colorSpaceSelector->cmbColorDepth->setIDList(sortedDepths);
     if (sortedDepths.contains(activeDepth)) {
         d->colorSpaceSelector->cmbColorDepth->setCurrent(activeDepth);
     }
 }
 
 void KisAdvancedColorSpaceSelector::fillDescription()
 {
     QString notApplicable = i18nc("Not Applicable, used where there's no colorants or gamma curve found","N/A");
     QString notApplicableTooltip = i18nc("@info:tooltip","This profile has no colorants.");
     QString profileName = i18nc("Shows up instead of the name when there's no profile","No Profile Found");
     QString whatIsColorant = i18n("Colorant in d50-adapted xyY.");
     //set colorants
-    QString s = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
-    const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
-    if (csf == 0) return;
-    QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
-    if (profileList.isEmpty()==false) {
+    const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
+    QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId);
+
+    if (!profileList.isEmpty()) {
         profileName = currentColorSpace()->profile()->name();
         if (currentColorSpace()->profile()->hasColorants()){
             QVector <double> colorants = currentColorSpace()->profile()->getColorantsxyY();
             QVector <double> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
             //QString text = currentColorSpace()->profile()->info() + " =" +
             d->colorSpaceSelector->lblXYZ_W->setText(nameWhitePoint(whitepoint));
             d->colorSpaceSelector->lblXYZ_W->setToolTip(QString::number(whitepoint[0], 'f', 4) + ", " + QString::number(whitepoint[1], 'f', 4) + ", " + QString::number(whitepoint[2], 'f', 4));
             d->colorSpaceSelector->TongueWidget->setToolTip("<html><head/><body><table><tr><th colspan='4'>"+i18nc("@info:tooltip","This profile has the following xyY colorants:")+"</th></tr><tr><td>"+
                i18n("Red:")  +"</td><td>"+QString::number(colorants[0], 'f', 4) + "</td><td>" + QString::number(colorants[1], 'f', 4) + "</td><td>" + QString::number(colorants[2], 'f', 4)+"</td></tr><tr><td>"+
                i18n("Green:")+"</td><td>"+QString::number(colorants[3], 'f', 4) + "</td><td>" + QString::number(colorants[4], 'f', 4) + "</td><td>" + QString::number(colorants[5], 'f', 4)+"</th></tr><tr><td>"+
                i18n("Blue:") +"</td><td>"+QString::number(colorants[6], 'f', 4) + "</td><td>" + QString::number(colorants[7], 'f', 4) + "</td><td>" + QString::number(colorants[8], 'f', 4)+"</th></tr></table></body></html>");
         } else {
             QVector <double> whitepoint2 = currentColorSpace()->profile()->getWhitePointxyY();
             d->colorSpaceSelector->lblXYZ_W->setText(nameWhitePoint(whitepoint2));
             d->colorSpaceSelector->lblXYZ_W->setToolTip(QString::number(whitepoint2[0], 'f', 4) + ", " + QString::number(whitepoint2[1], 'f', 4) + ", " + QString::number(whitepoint2[2], 'f', 4));
             d->colorSpaceSelector->TongueWidget->setToolTip(notApplicableTooltip);
         }
     } else {
         d->colorSpaceSelector->lblXYZ_W->setText(notApplicable);
         d->colorSpaceSelector->lblXYZ_W->setToolTip(notApplicableTooltip);
         d->colorSpaceSelector->TongueWidget->setToolTip(notApplicableTooltip);
     }
 
     //set TRC
     QVector <double> estimatedTRC(3);
     QString estimatedGamma = i18nc("Estimated Gamma indicates how the TRC (Tone Response Curve or Tone Reproduction Curve) is bent. A Gamma of 1.0 means linear.", "<b>Estimated Gamma</b>: ");
     QString estimatedsRGB = i18nc("This is for special Gamma types that LCMS cannot differentiate between", "<b>Estimated Gamma</b>: sRGB, L* or rec709 TRC");
     QString whatissRGB = i18nc("@info:tooltip","The Tone Response Curve of this color space is either sRGB, L* or rec709 TRC.");
     QString currentModelStr = d->colorSpaceSelector->cmbColorModels->currentItem().id();
 
     if (profileList.isEmpty()) {
         d->colorSpaceSelector->TongueWidget->setProfileDataAvailable(false);
         d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
     }
     else if (currentModelStr == "RGBA") {
         QVector <qreal> colorants = currentColorSpace()->profile()->getColorantsxyY();
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         if (currentColorSpace()->profile()->hasColorants()){
             d->colorSpaceSelector->TongueWidget->setRGBData(whitepoint, colorants);
         } else {
             colorants.fill(0.0);
             d->colorSpaceSelector->TongueWidget->setRGBData(whitepoint, colorants);
         }
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF redcurve;
         QPolygonF greencurve;
         QPolygonF bluecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 redcurve<<tonepoint;
                 tonepoint.setX(linear[1]);
                 greencurve<<tonepoint;
                 tonepoint.setX(linear[2]);
                 bluecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setRGBCurve(redcurve, greencurve, bluecurve);
         } else {
             QPolygonF curve = currentColorSpace()->estimatedTRCXYY();
             redcurve << curve.at(0) << curve.at(1) << curve.at(2) << curve.at(3) << curve.at(4);
             greencurve << curve.at(5) << curve.at(6) << curve.at(7) << curve.at(8) << curve.at(9);
             bluecurve << curve.at(10) << curve.at(11) << curve.at(12) << curve.at(13) << curve.at(14);
             d->colorSpaceSelector->TRCwidget->setRGBCurve(redcurve, greencurve, bluecurve);
         }
 
         if (estimatedTRC[0] == -1) {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+whatissRGB+"<br />"+estimatedCurve+"</body></html>");
         } else {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+estimatedGamma + QString::number(estimatedTRC[0]) + "," + QString::number(estimatedTRC[1]) + "," + QString::number(estimatedTRC[2])+"<br />"+estimatedCurve+"</body></html>");
         }
     }
     else if (currentModelStr == "GRAYA") {
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setGrayData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         if (estimatedTRC[0] == -1) {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+whatissRGB+"<br />"+estimatedCurve+"</body></html>");
         } else {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+estimatedGamma + QString::number(estimatedTRC[0])+"<br />"+estimatedCurve+"</body></html>");
         }
     }
     else if (currentModelStr == "CMYKA") {
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setCMYKData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         QPolygonF cyancurve;
         QPolygonF magentacurve;
         QPolygonF yellowcurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             QPolygonF curve = currentColorSpace()->estimatedTRCXYY();
             cyancurve << curve.at(0) << curve.at(1) << curve.at(2) << curve.at(3) << curve.at(4);
             magentacurve << curve.at(5) << curve.at(6) << curve.at(7) << curve.at(8) << curve.at(9);
             yellowcurve << curve.at(10) << curve.at(11) << curve.at(12) << curve.at(13) << curve.at(14);
             tonecurve << curve.at(15) << curve.at(16) << curve.at(17) << curve.at(18) << curve.at(19);
             d->colorSpaceSelector->TRCwidget->setCMYKCurve(cyancurve, magentacurve, yellowcurve, tonecurve);
         }
         d->colorSpaceSelector->TRCwidget->setToolTip(i18nc("@info:tooltip","Estimated Gamma cannot be retrieved for CMYK."));
     }
     else if (currentModelStr == "XYZA") {
         QString estimatedCurve = " Estimated curve: ";
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setXYZData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+estimatedGamma + QString::number(estimatedTRC[0])+"< br />"+estimatedCurve+"</body></html>");
     }
     else if (currentModelStr == "LABA") {
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setLABData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+i18nc("@info:tooltip","This is assumed to be the L * TRC. ")+"<br />"+estimatedCurve+"</body></html>");
     }
     else if (currentModelStr == "YCbCrA") {
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setYCbCrData(whitepoint);
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         d->colorSpaceSelector->TRCwidget->setToolTip(i18nc("@info:tooltip","Estimated Gamma cannot be retrieved for YCrCb."));
     }
 
     d->colorSpaceSelector->textProfileDescription->clear();
     if (profileList.isEmpty()==false) {
         d->colorSpaceSelector->textProfileDescription->append("<h3>"+i18nc("About <Profilename>","About ")  +  currentColorSpace()->name()  +  "/"  +  profileName  +  "</h3>");
         d->colorSpaceSelector->textProfileDescription->append("<p>"+ i18nc("ICC profile version","ICC Version: ")  + QString::number(currentColorSpace()->profile()->version())  +  "</p>");
         //d->colorSpaceSelector->textProfileDescription->append("<p>"+ i18nc("Who made the profile?","Manufacturer: ")  + currentColorSpace()->profile()->manufacturer()  +  "</p>"); //This would work if people actually wrote the manufacturer into the manufacturer fiedl...
         d->colorSpaceSelector->textProfileDescription->append("<p>"+ i18nc("What is the copyright? These are from embedded strings from the icc profile, so they default to english.","Copyright: ")  + currentColorSpace()->profile()->copyright()  +  "</p>");
     } else {
         d->colorSpaceSelector->textProfileDescription->append("<h3>" + profileName  +  "</h3>");
     }
 
     if (currentModelStr == "RGBA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is RGB",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/RGB_color_space\">RGB (Red, Green, Blue)</a></b>, is the color model used by screens and other light-based media.<br/>"
                                                                     "RGB is an additive color model: adding colors together makes them brighter. This color "
                                                                     "model is the most extensive of all color models, and is recommended as a model for painting,"
                                                                     "that you can later convert to other spaces. RGB is also the recommended colorspace for HDR editing.")+"</p>");
     } else if (currentModelStr == "CMYKA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is CMYK",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/CMYK_color_model\">CMYK (Cyan, Magenta, Yellow, Key)</a></b>, "
                                                                     "is the model used by printers and other ink-based media.<br/>"
                                                                     "CMYK is a subtractive model, meaning that adding colors together will turn them darker. Because of CMYK "
                                                                     "profiles being very specific per printer, it is recommended to work in RGB space, and then later convert "
                                                                     "to a CMYK profile, preferably one delivered by your printer. <br/>"
                                                                     "CMYK is <b>not</b> recommended for painting."
                                                                     "Unfortunately, Krita cannot retrieve colorants or the TRC for this space.")+"</p>");
     } else if (currentModelStr == "XYZA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is XYZ",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/CIE_1931_color_space\">CIE XYZ</a></b>"
                                                                     "is the space determined by the CIE as the space that encompasses all other colors, and used to "
                                                                     "convert colors between profiles. XYZ is an additive color model, meaning that adding colors together "
                                                                     "makes them brighter. XYZ is <b>not</b> recommended for painting, but can be useful to encode in. The Tone Response "
                                                                     "Curve is assumed to be linear.")+"</p>");
     } else if (currentModelStr == "GRAYA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is Grayscale",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/Grayscale\">Grayscale</a></b> only allows for "
                                                                     "gray values and transparent values. Grayscale images use half "
                                                                     "the memory and disk space compared to an RGB image of the same bit-depth.<br/>"
                                                                     "Grayscale is useful for inking and greyscale images. In "
                                                                     "Krita, you can mix Grayscale and RGB layers in the same image.")+"</p>");
     } else if (currentModelStr == "LABA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is LAB",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/Lab_color_space\">L*a*b</a></b>. <b>L<b> stands for Lightness, "
                                                                     "the <b>a</b> and <b>b</b> components represent color channels.<br/>"
                                                                     "L*a*b is a special model for color correction. It is based on human perception, meaning that it "
                                                                     "tries to encode the difference in lightness, red-green balance and yellow-blue balance. "
                                                                     "This makes it useful for color correction, but the vast majority of color maths in the blending "
                                                                     "modes do <b>not</b> work as expected here.<br/>"
                                                                     "Similarly, Krita does not support HDR in LAB, meaning that HDR images converted to LAB lose color "
                                                                     "information. This colorspace is <b>not</b> recommended for painting, nor for export, "
                                                                     "but best as a space to do post-processing in. The TRC is assumed to be the L* TRC.")+"</p>");
     } else if (currentModelStr == "YCbCrA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is YCbCr",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/YCbCr\">YCbCr (Luma, Blue Chroma, Red Chroma)</a></b>, is a "
                                                                     "model designed for video encoding. It is based on human perception, meaning that it tries to "
                                                                     "encode the difference in lightness, red-green balance and yellow-blue balance. Chroma in "
                                                                     "this case is then a word indicating a special type of saturation, in these cases the saturation "
                                                                     "of Red and Blue, of which the desaturated equivalents are Green and Yellow respectively. It "
                                                                     "is available to open up certain images correctly, but Krita does not currently ship a profile for "
                                                                     "this due to lack of open source ICC profiles for YCrCb.")+"</p>");
     }
 
     QString currentDepthStr = d->colorSpaceSelector->cmbColorDepth->currentItem().id();
 
     if (currentDepthStr == "U8") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 8",
                                                                     "<b>8 bit integer</b>: The default amount of colors per channel. Each channel will have 256 values available, "
                                                                     "leading to a total amount of 256*amount of channels. Recommended to use for images intended for the web, "
                                                                     "or otherwise simple images.")+"</p>");
     }
     else if (currentDepthStr == "U16") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 16",
                                                                     "<b>16 bit integer</b>: Also known as 'deep color'. 16 bit is ideal for editing images with a linear TRC, large "
                                                                     "color space, or just when you need more precise color blending. This does take twice as much space on "
                                                                     "the RAM and hard-drive than any given 8 bit image of the same properties, and for some devices it "
                                                                     "takes much more processing power. We recommend watching the RAM usage of the file carefully, or "
                                                                     "otherwise use 8 bit if your computer slows down. Take care to disable conversion optimization "
                                                                     "when converting from 16 bit/channel to 8 bit/channel.")+"</p>");
     }
     else if (currentDepthStr == "F16") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 16 bit float",
                                                                     "<b>16 bit floating point</b>: Also known as 'Half Floating Point', and the standard in VFX industry images. "
                                                                     "16 bit float is ideal for editing images with a linear Tone Response Curve, large color space, or just when you need "
                                                                     "more precise color blending. It being floating point is an absolute requirement for Scene Referred "
                                                                     "(HDR) images. This does take twice as much space on the RAM and hard-drive than any given 8 bit image "
                                                                     "of the same properties, and for some devices it takes much more processing power. We recommend watching "
                                                                     "the RAM usage of the file carefully, or otherwise use 8 bit if your computer slows down.")+"</p>");
     }
     else if (currentDepthStr == "F32") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 32bit float",
                                                                     "<b>32 bit float point</b>: Also known as 'Full Floating Point'. 32 bit float is ideal for editing images "
                                                                     "with a linear TRC, large color space, or just when you need more precise color blending. It being "
                                                                     "floating point is an absolute requirement for Scene Referred (HDR) images. This does take four times "
                                                                     "as much space on the RAM and hard-drive than any given 8 bit image of the same properties, and for "
                                                                     "some devices it takes much more processing power. We recommend watching the RAM usage of the file "
                                                                     "carefully, or otherwise use 8 bit if your computer slows down.")+"</p>");
     }
     else if (currentDepthStr == "F64") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 64bit float, but this isn't actually available in Krita at the moment.",\
                                                                     "<b>64 bit float point</b>: 64 bit float is as precise as it gets in current technology, and this depth is used "
                                                                     "most of the time for images that are generated or used as an input for software. It being floating point "
                                                                     "is an absolute requirement for Scene Referred (HDR) images. This does take eight times as much space on "
                                                                     "the RAM and hard-drive than any given 8 bit image of the same properties, and for some devices it takes "
                                                                     "much more processing power. We recommend watching the RAM usage of the file carefully, or otherwise use "
                                                                     "8 bit if your computer slows down.")+"</p>");
     }
     if (profileList.isEmpty()==false) {
         QString possibleConversionIntents = "<p>"+i18n("The following conversion intents are possible: ")+"<ul>";
         if (currentColorSpace()->profile()->supportsPerceptual()){
             possibleConversionIntents += "<li>"+i18n("Perceptual")+"</li>";
         }
         if (currentColorSpace()->profile()->supportsRelative()){
             possibleConversionIntents +=  "<li>"+i18n("Relative Colorimetric")+"</li>";
         }
         if (currentColorSpace()->profile()->supportsAbsolute()){
             possibleConversionIntents += "<li>"+i18n("Absolute Colorimetric")+"</li>";
         }
         if (currentColorSpace()->profile()->supportsSaturation()){
             possibleConversionIntents += "<li>"+i18n("Saturation")+"</li>";
         }
         possibleConversionIntents += "</ul></ul></p>";
         d->colorSpaceSelector->textProfileDescription->append(possibleConversionIntents);
     }
     if (profileName.contains("-elle-")) {
 
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("These are Elle Stone's notes on her profiles that we ship.",
                                                                     "<p><b>Extra notes on profiles by Elle Stone:</b></p>"
                                                                     "<p><i>Krita comes with a number of high quality profiles created by "
                                                                     "<a href=\"http://ninedegreesbelow.com\">Elle Stone</a>. This is a summary. Please check "
                                                                     "<a href=\"http://ninedegreesbelow.com/photography/lcms-make-icc-profiles.html\">the full documentation</a> as well.</i></p>"));
 
                 if (profileName.contains("ACES-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Quoting Wikipedia, 'Academy Color Encoding System (ACES) is a color image "
                                                                         "encoding system proposed by the Academy of Motion Picture Arts and Sciences that will allow for "
                                                                         "a fully encompassing color accurate workflow, with 'seamless interchange of high quality motion "
                                                                         "picture images regardless of source'.</p>"));
         }
         if (profileName.contains("ACEScg-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The ACEScg color space is smaller than the ACES color space, but large enough to contain the 'Rec-2020 gamut "
                                                                         "and the DCI-P3 gamut', unlike the ACES color space it has no negative values and contains only few colors "
                                                                         "that fall just barely outside the area of real colors humans can see</p>"));
         }
         if (profileName.contains("ClayRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>To avoid possible copyright infringement issues, I used 'ClayRGB' (following ArgyllCMS) as the base name "
                                                                         "for these profiles. As used below, 'Compatible with Adobe RGB 1998' is terminology suggested in the preamble "
                                                                         "to the AdobeRGB 1998 color space specifications.</p><p>"
                                                                         "The Adobe RGB 1998 color gamut covers a higher "
                                                                         "percentage of real-world cyans, greens, and yellow-greens than sRGB, but still doesn't include all printable "
                                                                         "cyans, greens, yellow-greens, especially when printing using today's high-end, wider gamut, ink jet printers. "
                                                                         "BetaRGB (not included in the profile pack) and Rec.2020 are better matches for the color gamuts of today's "
                                                                         "wide gamut printers.</p><p>"
                                                                         "The Adobe RGB 1998 color gamut is a reasonable approximation to some of today's "
                                                                         "high-end wide gamut monitors.</p>"));
         }
         if (profileName.contains("AllColorsRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>This profile's color gamut is roughly the same size and shape as the ACES color space gamut, "
                                                                         "and like the ACES color space, AllColorsRGB holds all possible real colors. But AllColorsRGB "
                                                                         "actually has a slightly larger color gamut (to capture some fringe colors that barely qualify "
                                                                         "as real when viewed by the standard observer) and uses the D50 white point.</p><p>"
                                                                         "Just like the ACES color space, AllColorsRGB holds a high percentage of imaginary colors. See the Completely "
                                                                         "<a href=\"http://ninedegreesbelow.com/photography/xyz-rgb.html\">"
                                                                         "Painless Programmer's Guide to XYZ, RGB, ICC, xyY, and TRCs</a> for more information about imaginary "
                                                                         "colors.</p><p>"
                                                                         "There is no particular reason why anyone would want to use this profile "
                                                                         "for editing, unless one needs to make sure your color space really does hold all "
                                                                         "possible real colors.</p>"));
         }
         if (profileName.contains("CIERGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>This profile is included mostly for its historical significance. "
                                                                         "It's the color space that was used in the original color matching experiments "
                                                                         "that led to the creation of the XYZ reference color space.</p><p>"
                                                                         "The ASTM E white point "
                                                                         "is probably the right E white point to use when making the CIERGB color space profile. "
                                                                         "It's not clear to me what the correct CIERGB primaries really are. "
                                                                         "Lindbloom gives one set. The LCMS version 1 tutorial gives a different set. "
                                                                         "Experts in the field contend that the real primaries "
                                                                         "should be calculated from the spectral wavelengths, so I did.</p>"));
         }
         if (profileName.contains("IdentityRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The IdentityRGB working space is included in the profile pack because it's a mathematically "
                                                                         "obvious way to include all possible visible colors, though it has a higher percentage of "
                                                                         "imaginary colors than the ACES and AllColorsRGB color spaces. I cannot think of any reason "
                                                                         "why you'd ever want to actually edit images in the IdentityRGB working space.</p>"));
         }
         if (profileName.contains("LargeRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>To avoid possible copyright infringement issues, I used 'LargeRGB' (following RawTherapee) "
                                                                         "as the base name for these profiles.<p>"
                                                                         "Kodak designed the RIMM/ROMM (ProPhotoRGB) color "
                                                                         "gamut to include all printable and most real world colors. It includes some imaginary colors "
                                                                         "and excludes some of the real world blues and violet blues that can be captured by digital "
                                                                         "cameras. It also excludes some very saturated 'camera-captured' yellows as interpreted by "
                                                                         "some (and probably many) camera matrix input profiles.<p>"
                                                                         "The ProPhotoRGB primaries are "
                                                                         "hard-coded into Adobe products such as Lightroom and the Dng-DCP camera 'profiles'. However, "
                                                                         "other than being large enough to hold a lot of colors, ProPhotoRGB has no particular merit "
                                                                         "as an RGB working space. Personally and for most editing purposes, I recommend BetaRGB, Rec2020, "
                                                                         "or the ACEScg profiles ProPhotoRGB.</p>"));
         }
         if (profileName.contains("Rec2020-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Rec.2020 is the up-and-coming replacement for the thoroughly outdated sRGB color space. As of "
                                                                         "June 2015, very few (if any) display devices (and certainly no affordable display devices) can "
                                                                         "display all of Rec.2020. However, display technology is closing in on Rec.2020, movies are "
                                                                         "already being made for Rec.2020, and various cameras offer support for Rec.2020. And in the "
                                                                         "digital darkroom Rec.2020 is much more suitable as a general RGB working space than the "
                                                                         "exceedingly small sRGB color space.</p>"));
         }
         if (profileName.contains("sRGB-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Hewlett-Packard and Microsoft designed sRGB to match the color gamut of consumer-grade CRTs "
                                                                         "from the 1990s. sRGB is the standard color space for the world wide web and is still the best "
                                                                         "choice for exporting images to the internet.</p><p>"
                                                                         "The sRGB color gamut was a good match to "
                                                                         "calibrated decent quality CRTs. But sRGB is not a good match to many consumer-grade LCD monitors, "
                                                                         "which often cannot display the more saturated sRGB blues and magentas (the good news: as technology "
                                                                         "progresses, wider gamuts are trickling down to consumer grade monitors).</p><p>"
                                                                         "Printer color gamuts can easily exceed the sRGB color gamut in cyans, greens, and yellow-greens. Colors from interpolated "
                                                                         "camera raw files also often exceed the sRGB color gamut.</p><p>"
                                                                         "As a very relevant aside, using perceptual "
                                                                         "intent when converting to sRGB does not magically makes otherwise out of gamut colors fit inside the "
                                                                         "sRGB color gamut! The standard sRGB color space (along with all the other the RGB profiles provided "
                                                                         "in my profile pack) is a matrix profile, and matrix profiles don't have perceptual intent tables.</p>"));
         }
         if (profileName.contains("WideRGB-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>To avoid possible copyright infringement issues, I used 'WideRGB' as the base name for these profiles.</p><p>"
                                                                         "WideGamutRGB was designed by Adobe to be a wide gamut color space that uses spectral colors "
                                                                         "as its primaries. Pascale's primary values produce a profile that matches old V2 Widegamut profiles "
                                                                         "from Adobe and Canon. It is an interesting color space, but shortly after its introduction, Adobe "
                                                                         "switched their emphasis to the ProPhotoRGB color space.</p>"));
         }
         if (profileName.contains("Gray-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>These profiles are for use with RGB images that have been converted to monotone gray (black and white). "
                                                                         "The main reason to convert from RGB to Gray is to save the file space needed to encode the image. "
                                                                         "Google places a premium on fast-loading web pages, and images are one of the slower-loading elements "
                                                                         "of a web page. So converting black and white images to Grayscale images does save some kilobytes. "
                                                                         " For grayscale images uploaded to the internet, convert the image to the V2 Gray profile with the sRGB TRC.</p>"));
         }
         if (profileName.contains("-g10")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The profiles that end in '-g10.icc' are linear gamma (gamma=1.0, 'linear light', etc) profiles and "
                                                                         "should only be used when editing at high bit depths (16-bit floating point, 16-bit integer, 32-bit "
                                                                         "floating point, 32-bit integer). Many editing operations produce better results in linear gamma color "
                                                                         "spaces.</p>"));
         }
         if (profileName.contains("-labl")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The profiles that end in '-labl.icc' have perceptually uniform TRCs. A few editing operations really "
                                                                         "should be done on perceptually uniform RGB. Make sure you use the V4 versions for editing high bit depth "
                                                                         "images.</p>"));
         }
         if (profileName.contains("-srgbtrc") || profileName.contains("-g22") || profileName.contains("-g18") || profileName.contains("-bt709")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The profiles that end in '-srgbtrc.icc', '-g22.icc', and '-bt709.icc' have approximately but not exactly "
                                                                         "perceptually uniform TRCs. ProPhotoRGB's gamma=1.8 TRC is not quite as close to being perceptually uniform.</p>"));
         }
         if (d->colorSpaceSelector->cmbColorDepth->currentItem().id()=="U8") {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>When editing 8-bit images, you should use a profile with a small color gamut and an approximately or "
                                                                         "exactly perceptually uniform TRC. Of the profiles supplied in my profile pack, only the sRGB and AdobeRGB1998 "
                                                                         "(ClayRGB) color spaces are small enough for 8-bit editing. Even with the AdobeRGB1998 color space you need to "
                                                                         "be careful to not cause posterization. And of course you cannot use the linear gamma versions of these profiles "
                                                                         "for 8-bit editing.</p>"));
         }
         if (profileName.contains("-V4-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Use V4 profiles for editing images using high bit depth image editors that use LCMS as the Color Management Module. "
                                                                         "This includes Krita, digiKam/showFoto, and GIMP 2.9.</p>"));
         }
         if (profileName.contains("-V2-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Use V2 profiles for exporting finished images to be uploaded to the web or for use with imaging software that "
                                                                         "cannot read V4 profiles.</p>"));
         }
     }
 
 
     d->colorSpaceSelector->textProfileDescription->moveCursor(QTextCursor::Start);
 
 }
 
 QString KisAdvancedColorSpaceSelector::nameWhitePoint(QVector <double> whitePoint) {
     QString name=(QString::number(whitePoint[0]) + ", " + QString::number(whitePoint[1], 'f', 4));
     //A   (0.451170, 0.40594) (2856K)(tungsten)
     if ((whitePoint[0]>0.451170-0.005 && whitePoint[0]<0.451170 + 0.005) &&
             (whitePoint[1]>0.40594-0.005 && whitePoint[1]<0.40594 + 0.005)){
         name="A";
         return name;
     }
     //B   (0.34980, 0.35270) (4874K) (Direct Sunlight at noon)(obsolete)
     //C   (0.31039, 0.31905) (6774K) (avarage/north sky daylight)(obsolete)
     //D50 (0.34773, 0.35952) (5003K) (Horizon Light, default color of white paper, ICC profile standard illuminant)
     if ((whitePoint[0]>0.34773-0.005 && whitePoint[0]<0.34773 + 0.005) &&
             (whitePoint[1]>0.35952-0.005 && whitePoint[1]<0.35952 + 0.005)){
         name="D50";
         return name;
     }
     //D55 (0.33411,	0.34877) (5503K) (Mid-morning / Mid-afternoon Daylight)
     if ((whitePoint[0]>0.33411-0.001 && whitePoint[0]<0.33411 + 0.001) &&
             (whitePoint[1]>0.34877-0.005 && whitePoint[1]<0.34877 + 0.005)){
         name="D55";
         return name;
     }
     //D60 (0.3217, 0.3378) (~6000K) (ACES colorspace default)
     if ((whitePoint[0]>0.3217-0.001 && whitePoint[0]<0.3217 + 0.001) &&
             (whitePoint[1]>0.3378-0.005 && whitePoint[1]<0.3378 + 0.005)){
         name="D60";
         return name;
     }
     //D65 (0.31382, 0.33100) (6504K) (Noon Daylight, default for computer and tv screens, sRGB default)
     //Elle's are old school with 0.3127 and 0.3289
     if ((whitePoint[0]>0.31382-0.002 && whitePoint[0]<0.31382 + 0.002) &&
             (whitePoint[1]>0.33100-0.005 && whitePoint[1]<0.33100 + 0.002)){
         name="D65";
         return name;
     }
     //D75 (0.29968, 0.31740) (7504K) (North sky Daylight)
     if ((whitePoint[0]>0.29968-0.001 && whitePoint[0]<0.29968 + 0.001) &&
             (whitePoint[1]>0.31740-0.005 && whitePoint[1]<0.31740 + 0.005)){
         name="D75";
         return name;
     }
     //E   (1/3, 1/3)         (5454K) (Equal Energy. CIERGB default)
     if ((whitePoint[0]>(1.0/3.0)-0.001 && whitePoint[0]<(1.0/3.0) + 0.001) &&
             (whitePoint[1]>(1.0/3.0)-0.001 && whitePoint[1]<(1.0/3.0) + 0.001)){
         name="E";
         return name;
     }
     //The F series seems to sorta overlap with the D series, so I'll just leave them in comment here.//
     //F1  (0.31811, 0.33559) (6430K) (Daylight Fluorescent)
     //F2  (0.37925, 0.36733) (4230K) (Cool White Fluorescent)
     //F3  (0.41761, 0.38324) (3450K) (White Florescent)
     //F4  (0.44920, 0.39074) (2940K) (Warm White Fluorescent)
     //F5  (0.31975, 0.34246) (6350K) (Daylight Fluorescent)
     //F6  (0.38660, 0.37847) (4150K) (Lite White Fluorescent)
     //F7  (0.31569, 0.32960) (6500K) (D65 simulator, Daylight simulator)
     //F8  (0.34902, 0.35939) (5000K) (D50 simulator)
     //F9  (0.37829, 0.37045) (4150K) (Cool White Deluxe Fluorescent)
     //F10 (0.35090, 0.35444) (5000K) (Philips TL85, Ultralume 50)
     //F11 (0.38541, 0.37123) (4000K) (Philips TL84, Ultralume 40)
     //F12 (0.44256, 0.39717) (3000K) (Philips TL83, Ultralume 30)
 
     return name;
 }
 
 const KoColorSpace* KisAdvancedColorSpaceSelector::currentColorSpace()
 {
     QString check = "";
     if (d->colorSpaceSelector->lstProfile->currentItem()) {
         check = d->colorSpaceSelector->lstProfile->currentItem()->text();
     } else if (d->colorSpaceSelector->lstProfile->item(0)) {
         check = d->colorSpaceSelector->lstProfile->item(0)->text();
     }
     return KoColorSpaceRegistry::instance()->colorSpace(d->colorSpaceSelector->cmbColorModels->currentItem().id(),
                                                         d->colorSpaceSelector->cmbColorDepth->currentItem().id(),
                                                         check);
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentColorModel(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorModels->setCurrent(id);
     fillLstProfiles();
     fillCmbDepths(id);
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentColorDepth(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorDepth->setCurrent(id);
     fillLstProfiles();
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentProfile(const QString& name)
 {
     QList<QListWidgetItem *> Items= d->colorSpaceSelector->lstProfile->findItems(name, Qt::MatchStartsWith);
     d->colorSpaceSelector->lstProfile->setCurrentItem(Items.at(0));
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentColorSpace(const KoColorSpace* colorSpace)
 {
     if (!colorSpace) {
         return;
     }
     setCurrentColorModel(colorSpace->colorModelId());
     setCurrentColorDepth(colorSpace->colorDepthId());
     setCurrentProfile(colorSpace->profile()->name());
 }
 
 void KisAdvancedColorSpaceSelector::colorSpaceChanged()
 {
     bool valid = d->colorSpaceSelector->lstProfile->count() != 0;
     emit(selectionChanged(valid));
     if (valid) {
         emit colorSpaceChanged(currentColorSpace());
     }
 }
 
 void KisAdvancedColorSpaceSelector::installProfile()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::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) {
         QUrl file(profileName);
         if (!QFile::copy(profileName, saveLocation  +  file.fileName())) {
             dbgKrita << "Could not install profile!";
             return;
         }
         iccEngine->addProfile(saveLocation  +  file.fileName());
 
     }
 
     fillLstProfiles();
 }
diff --git a/libs/ui/widgets/kis_cie_tongue_widget.cpp b/libs/ui/widgets/kis_cie_tongue_widget.cpp
index 9afa11441f..b255f47489 100644
--- a/libs/ui/widgets/kis_cie_tongue_widget.cpp
+++ b/libs/ui/widgets/kis_cie_tongue_widget.cpp
@@ -1,737 +1,735 @@
 /* 
  * Copyright (C) 2015 by Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  *
  * Based on the Digikam CIE Tongue widget
  * Copyright (C) 2006-2013 by Gilles Caulier <caulier dot gilles at gmail dot com>
  *
  * Any source code are inspired from lprof project and
  * Copyright (C) 1998-2001 Marti Maria
  *
  * 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, 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.
  **/
 
 /**
 The following table gives the CIE  color matching functions
 \f$\bar{x}(\lambda)\f$, \f$\bar{y}(\lambda)\f$, and
 \f$\bar{z}(\lambda)\f$, for wavelengths \f$\lambda\f$ at 5 nanometer
 increments from 380 nm through 780 nm. This table is used in conjunction
 with Planck's law for the energy spectrum of a black body at a given
 temperature to plot the black body curve on the CIE chart.
  
 The following table gives the spectral chromaticity co-ordinates
 \f$x(\lambda)\f$ and \f$y(\lambda)\f$ for wavelengths in 5 nanometer
 increments from 380 nm through 780 nm. These coordinates represent the
 position in the CIE x-y space of pure spectral colors of the given
 wavelength, and thus define the outline of the CIE "tongue" diagram.
 */
 
 #include <QPointF>
 #include <QPainter>
 #include <QFile>
 #include <QTimer>
 #include <QPaintEvent>
 #include <QImage>
 #include <cmath>
 
 #include <klocalizedstring.h>
 #include <kpixmapsequence.h>
 
 #include <kis_icon.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_cie_tongue_widget.h"
 
 static const double spectral_chromaticity[81][3] =
 {
     { 0.1741, 0.0050 },               // 380 nm
     { 0.1740, 0.0050 },
     { 0.1738, 0.0049 },
     { 0.1736, 0.0049 },
     { 0.1733, 0.0048 },
     { 0.1730, 0.0048 },
     { 0.1726, 0.0048 },
     { 0.1721, 0.0048 },
     { 0.1714, 0.0051 },
     { 0.1703, 0.0058 },
     { 0.1689, 0.0069 },
     { 0.1669, 0.0086 },
     { 0.1644, 0.0109 },
     { 0.1611, 0.0138 },
     { 0.1566, 0.0177 },
     { 0.1510, 0.0227 },
     { 0.1440, 0.0297 },
     { 0.1355, 0.0399 },
     { 0.1241, 0.0578 },
     { 0.1096, 0.0868 },
     { 0.0913, 0.1327 },
     { 0.0687, 0.2007 },
     { 0.0454, 0.2950 },
     { 0.0235, 0.4127 },
     { 0.0082, 0.5384 },
     { 0.0039, 0.6548 },
     { 0.0139, 0.7502 },
     { 0.0389, 0.8120 },
     { 0.0743, 0.8338 },
     { 0.1142, 0.8262 },
     { 0.1547, 0.8059 },
     { 0.1929, 0.7816 },
     { 0.2296, 0.7543 },
     { 0.2658, 0.7243 },
     { 0.3016, 0.6923 },
     { 0.3373, 0.6589 },
     { 0.3731, 0.6245 },
     { 0.4087, 0.5896 },
     { 0.4441, 0.5547 },
     { 0.4788, 0.5202 },
     { 0.5125, 0.4866 },
     { 0.5448, 0.4544 },
     { 0.5752, 0.4242 },
     { 0.6029, 0.3965 },
     { 0.6270, 0.3725 },
     { 0.6482, 0.3514 },
     { 0.6658, 0.3340 },
     { 0.6801, 0.3197 },
     { 0.6915, 0.3083 },
     { 0.7006, 0.2993 },
     { 0.7079, 0.2920 },
     { 0.7140, 0.2859 },
     { 0.7190, 0.2809 },
     { 0.7230, 0.2770 },
     { 0.7260, 0.2740 },
     { 0.7283, 0.2717 },
     { 0.7300, 0.2700 },
     { 0.7311, 0.2689 },
     { 0.7320, 0.2680 },
     { 0.7327, 0.2673 },
     { 0.7334, 0.2666 },
     { 0.7340, 0.2660 },
     { 0.7344, 0.2656 },
     { 0.7346, 0.2654 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 },
     { 0.7347, 0.2653 }  // 780 nm
 };
 
 class Q_DECL_HIDDEN KisCIETongueWidget::Private
 {
 public:
  
     Private() :
         profileDataAvailable(false),
         needUpdatePixmap(false),
         cieTongueNeedsUpdate(true),
         uncalibratedColor(false),
         xBias(0),
         yBias(0),
         pxcols(0),
         pxrows(0),
         progressCount(0),
         gridside(0),
         progressTimer(0),
         Primaries(9),
         whitePoint(3)
         
     {
         progressPix = KPixmapSequence("process-working", KisIconUtils::SizeSmallMedium);
     }
     
     bool            profileDataAvailable;
     bool            needUpdatePixmap;
     bool            cieTongueNeedsUpdate;
     bool            uncalibratedColor;
  
     int             xBias;
     int             yBias;
     int             pxcols;
     int             pxrows;
     int             progressCount;           // Position of animation during loading/calculation.
  
     double          gridside;
  
     QPainter        painter;
  
     QTimer*         progressTimer;
  
     QPixmap         pixmap;
     QPixmap         cietongue;
     QPixmap         gamutMap;
     KPixmapSequence progressPix;
  
     QVector <double> Primaries;
     QVector <double> whitePoint;
     QPolygonF       gamut;
     model colorModel;
 };
 
 KisCIETongueWidget::KisCIETongueWidget(QWidget *parent) :
     QWidget(parent), d(new Private)
 {
     d->progressTimer = new QTimer(this);
     setAttribute(Qt::WA_DeleteOnClose);
     
     d->Primaries.resize(9);
     d->Primaries.fill(0.0);
     d->whitePoint.resize(3);
     d->whitePoint<<0.34773<<0.35952<<1.0;
     d->gamut = QPolygonF();
 
     connect(d->progressTimer, SIGNAL(timeout()),
             this, SLOT(slotProgressTimerDone()));
 }
 
 KisCIETongueWidget::~KisCIETongueWidget()
 {
     delete d;
 }
 
 int KisCIETongueWidget::grids(double val) const
 {
     return (int) floor(val * d->gridside + 0.5);
 }
 
 void KisCIETongueWidget::setProfileData(QVector <double> p, QVector <double> w, bool profileData)
 {
     d->profileDataAvailable = profileData;
     if (profileData){
         d->Primaries= p;
         
         d->whitePoint = w;
         d->needUpdatePixmap = true;      
     } else {
         return;
     }
 }
 void KisCIETongueWidget::setGamut(QPolygonF gamut)
 {
     d->gamut=gamut;
 }
 void KisCIETongueWidget::setRGBData(QVector <double> whitepoint, QVector <double> colorants)
 {
     if (colorants.size()==9){
         d->Primaries= colorants;
         
         d->whitePoint = whitepoint;
         d->needUpdatePixmap = true;
         d->colorModel = KisCIETongueWidget::RGBA;
         d->profileDataAvailable = true;
     } else {
         return;
     }
 }
 void KisCIETongueWidget::setCMYKData(QVector <double> whitepoint)
 {
     if (whitepoint.size()==3){
         //d->Primaries= colorants;
         
         d->whitePoint = whitepoint;
         d->needUpdatePixmap = true;
         d->colorModel = KisCIETongueWidget::CMYKA;
         d->profileDataAvailable = true;
     } else {
         return;
     }
 }
 void KisCIETongueWidget::setXYZData(QVector <double> whitepoint)
 {
     if (whitepoint.size()==3){
         d->whitePoint = whitepoint;
         d->needUpdatePixmap = true;
         d->colorModel = KisCIETongueWidget::XYZA;
         d->profileDataAvailable = true;
     } else {
         return;
     }
 }
 void KisCIETongueWidget::setGrayData(QVector <double> whitepoint)
 {
     if (whitepoint.size()==3){
         d->whitePoint = whitepoint;
         d->needUpdatePixmap = true;
         d->colorModel = KisCIETongueWidget::GRAYA;
         d->profileDataAvailable = true;
     } else {
         return;
     }
 }
 void KisCIETongueWidget::setLABData(QVector <double> whitepoint)
 {
     if (whitepoint.size()==3){
         d->whitePoint = whitepoint;
         d->needUpdatePixmap = true;
         d->colorModel = KisCIETongueWidget::LABA;
         d->profileDataAvailable = true;
     } else {
         return;
     }
 }
 void KisCIETongueWidget::setYCbCrData(QVector <double> whitepoint)
 {
     if (whitepoint.size()==3){
         d->whitePoint = whitepoint;
         d->needUpdatePixmap = true;
         d->colorModel = KisCIETongueWidget::YCbCrA;
         d->profileDataAvailable = true;
     } else {
         return;
     }
 }
 
 void KisCIETongueWidget::setProfileDataAvailable(bool dataAvailable)
 {
     d->profileDataAvailable = dataAvailable;
 }
 void KisCIETongueWidget::mapPoint(int& icx, int& icy, QPointF xy)
 {
     icx = (int) floor((xy.x() * (d->pxcols - 1)) + .5);
     icy = (int) floor(((d->pxrows - 1) - xy.y() * (d->pxrows - 1)) + .5);
 }
  
 void KisCIETongueWidget::biasedLine(int x1, int y1, int x2, int y2)
 {
     d->painter.drawLine(x1 + d->xBias, y1, x2 + d->xBias, y2);
 }
  
 void KisCIETongueWidget::biasedText(int x, int y, const QString& txt)
 {
     d->painter.drawText(QPoint(d->xBias + x, y), txt);
 }
  
 QRgb KisCIETongueWidget::colorByCoord(double x, double y)
 {
     // Get xyz components scaled from coordinates
  
     double cx =       ((double) x) / (d->pxcols - 1);
     double cy = 1.0 - ((double) y) / (d->pxrows - 1);
     double cz = 1.0 - cx - cy;
  
     // Project xyz to XYZ space. Note that in this
     // particular case we are substituting XYZ with xyz
     
     //Need to use KoColor here.
-    QString space = KoColorSpaceRegistry::instance()->colorSpaceId("XYZA", "U8");
-    QString profile = KoColorSpaceRegistry::instance()->colorSpaceFactory(space)->defaultProfile();
-    const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "U8", profile);
+    const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "U8");
     quint8 data[4]; 
     data[0]= cx*255;
     data[1]= cy*255;
     data[2]= cz*255;
     data[3]= 1.0*255;
     KoColor colXYZ(data, xyzColorSpace);
     QColor colRGB = colXYZ.toQColor();
     return qRgb(colRGB.red(), colRGB.green(), colRGB.blue());
 }
  
 void KisCIETongueWidget::outlineTongue()
 {
     int lx=0, ly=0;
     int fx=0, fy=0;
  
     for (int x = 380; x <= 700; x += 5)
     {
         int ix = (x - 380) / 5;
 
         QPointF * p = new QPointF(spectral_chromaticity[ix][0], spectral_chromaticity[ix][1]);
         int icx, icy;
         mapPoint(icx, icy, * p);
  
         if (x > 380)
         {
             biasedLine(lx, ly, icx, icy);
         }
         else
         {
             fx = icx;
             fy = icy;
         }
  
         lx = icx;
         ly = icy;
     }
  
     biasedLine(lx, ly, fx, fy);
 }
  
 void KisCIETongueWidget::fillTongue()
 {
     QImage Img = d->cietongue.toImage();
  
     int x;
  
     for (int y = 0; y < d->pxrows; ++y)
     {
         int xe = 0;
  
         // Find horizontal extents of tongue on this line.
  
         for (x = 0; x < d->pxcols; ++x)
         {
             if (QColor(Img.pixel(x + d->xBias, y)) != QColor(Qt::black))
             {
                 for (xe = d->pxcols - 1; xe >= x; --xe)
                 {
                     if (QColor(Img.pixel(xe + d->xBias, y)) != QColor(Qt::black))
                     {
                         break;
                     }
                 }
  
                 break;
             }
         }
  
         if (x < d->pxcols)
         {
             for ( ; x <= xe; ++x)
             {
                 QRgb Color = colorByCoord(x, y);
                 Img.setPixel(x + d->xBias, y, Color);
             }
         }
     }
  
     d->cietongue = QPixmap::fromImage(Img, Qt::AvoidDither);
 }
  
 void KisCIETongueWidget::drawTongueAxis()
 {
     QFont font;
     font.setPointSize(6);
     d->painter.setFont(font);
  
     d->painter.setPen(qRgb(255, 255, 255));
  
     biasedLine(0, 0,           0,           d->pxrows - 1);
     biasedLine(0, d->pxrows-1, d->pxcols-1, d->pxrows - 1);
  
     for (int y = 1; y <= 9; y += 1)
     {
         QString s;
         int xstart = (y * (d->pxcols - 1)) / 10;
         int ystart = (y * (d->pxrows - 1)) / 10;
  
         s.sprintf("0.%d", y);
         biasedLine(xstart, d->pxrows - grids(1), xstart,   d->pxrows - grids(4));
         biasedText(xstart - grids(11), d->pxrows + grids(15), s);
  
         s.sprintf("0.%d", 10 - y);
         biasedLine(0, ystart, grids(3), ystart);
         biasedText(grids(-25), ystart + grids(5), s);
     }
 }
  
 void KisCIETongueWidget::drawTongueGrid()
 {
     d->painter.setPen(qRgb(128, 128, 128));
     d->painter.setOpacity(0.5);
  
     for (int y = 1; y <= 9; y += 1)
     {
         int xstart =  (y * (d->pxcols - 1)) / 10;
         int ystart =  (y * (d->pxrows - 1)) / 10;
  
         biasedLine(xstart, grids(4), xstart,   d->pxrows - grids(4) - 1);
         biasedLine(grids(7), ystart, d->pxcols-1-grids(7), ystart);
     }
     d->painter.setOpacity(1.0);
 }
  
 void KisCIETongueWidget::drawLabels()
 {
     QFont font;
     font.setPointSize(5);
     d->painter.setFont(font);
  
     for (int x = 450; x <= 650; x += (x > 470 && x < 600) ? 5 : 10)
     {
         QString wl;
         int bx = 0, by = 0, tx, ty;
  
         if (x < 520)
         {
             bx = grids(-22);
             by = grids(2);
         }
         else if (x < 535)
         {
             bx = grids(-8);
             by = grids(-6);
         }
         else
         {
             bx = grids(4);
         }
  
         int ix = (x - 380) / 5;
  
         QPointF * p = new QPointF(spectral_chromaticity[ix][0],
                        spectral_chromaticity[ix][1]);
  
         int icx, icy;
         mapPoint(icx, icy, * p);
  
         tx = icx + ((x < 520) ? grids(-2) : ((x >= 535) ? grids(2) : 0));
         ty = icy + ((x < 520) ? 0 : ((x >= 535) ? grids(-1) : grids(-2)));
  
         d->painter.setPen(qRgb(255, 255, 255));
         biasedLine(icx, icy, tx, ty);
  
         QRgb Color = colorByCoord(icx, icy);
         d->painter.setPen(Color);
  
         wl.sprintf("%d", x);
         biasedText(icx+bx, icy+by, wl);
     }
 }
  
 void KisCIETongueWidget::drawSmallElipse(QPointF xy, int r, int g, int b, int sz)
 {
     int icx, icy;
  
     mapPoint(icx, icy, xy);
     d->painter.save();
     d->painter.setRenderHint(QPainter::Antialiasing);
     d->painter.setPen(qRgb(r, g, b));
     d->painter.drawEllipse(icx + d->xBias- sz/2, icy-sz/2, sz, sz);
     d->painter.setPen(qRgb(r/2, g/2, b/2));
     int sz2 = sz-2;
     d->painter.drawEllipse(icx + d->xBias- sz2/2, icy-sz2/2, sz2, sz2);
     d->painter.restore();
 }
  
 void KisCIETongueWidget::drawColorantTriangle()
 {
     d->painter.save();
     d->painter.setPen(qRgb(80, 80, 80));
     d->painter.setRenderHint(QPainter::Antialiasing);
     if (d->colorModel ==KisCIETongueWidget::RGBA) {
         drawSmallElipse((QPointF(d->Primaries[0],d->Primaries[1])),   255, 128, 128, 6);
         drawSmallElipse((QPointF(d->Primaries[3],d->Primaries[4])), 128, 255, 128, 6);
         drawSmallElipse((QPointF(d->Primaries[6],d->Primaries[7])),  128, 128, 255, 6);
         
         int x1, y1, x2, y2, x3, y3;
  
         mapPoint(x1, y1, (QPointF(d->Primaries[0],d->Primaries[1])) );
         mapPoint(x2, y2, (QPointF(d->Primaries[3],d->Primaries[4])) );
         mapPoint(x3, y3, (QPointF(d->Primaries[6],d->Primaries[7])) );
         
         biasedLine(x1, y1, x2, y2);
         biasedLine(x2, y2, x3, y3);
         biasedLine(x3, y3, x1, y1);
     } /*else if (d->colorModel ==CMYK){
         for (i=0; i<d->Primaries.size();i+++){
             drawSmallElipse((QPointF(d->Primaries[0],d->Primaries[1])),   160, 160, 160, 6);//greyscale for now
             //int x1, y1, x2, y2;
             //mapPoint(x1, y1, (QPointF(d->Primaries[i],d->Primaries[i+1])) );
             //mapPoint(x2, y2, (QPointF(d->Primaries[i+3],d->Primaries[i+4])) );
             //biasedLine(x1, y1, x2, y2);
         }
     }
     */
  
     d->painter.restore();
 }
  
 void KisCIETongueWidget::drawWhitePoint()
 {
     drawSmallElipse(QPointF (d->whitePoint[0],d->whitePoint[1]),  255, 255, 255, 8);
 }
 
 void KisCIETongueWidget::drawGamut()
 {
     d->gamutMap=QPixmap(size());
     d->gamutMap.fill(Qt::black);
     QPainter gamutPaint;
     gamutPaint.begin(&d->gamutMap);
     QPainterPath path;
     //gamutPaint.setCompositionMode(QPainter::CompositionMode_Clear);
     gamutPaint.setRenderHint(QPainter::Antialiasing);
     path.setFillRule(Qt::WindingFill);
     gamutPaint.setBrush(Qt::white);
     gamutPaint.setPen(Qt::white);
     int x, y = 0;
     if (!d->gamut.empty()) {
         gamutPaint.setOpacity(0.5);
         if (d->colorModel == KisCIETongueWidget::RGBA) {
             mapPoint(x, y, (QPointF(d->Primaries[0],d->Primaries[1])) );
             path.moveTo(QPointF(x + d->xBias,y));
             mapPoint(x, y, (QPointF(d->Primaries[3],d->Primaries[4])) );
             path.lineTo(QPointF(x + d->xBias,y));
             mapPoint(x, y, (QPointF(d->Primaries[6],d->Primaries[7])) );
             path.lineTo(QPointF(x + d->xBias,y));
             mapPoint(x, y, (QPointF(d->Primaries[0],d->Primaries[1])) );
             path.lineTo(QPointF(x + d->xBias,y));
         }
         gamutPaint.drawPath(path);
         gamutPaint.setOpacity(1.0);
         foreach (QPointF Point, d->gamut) {
             mapPoint(x, y, Point);
             gamutPaint.drawEllipse(x + d->xBias- 2, y-2, 4, 4);
             //Point.setX(x);
             //Point.setY(y);
             //path.lineTo(Point);
         }
     }
     
     gamutPaint.end();
     d->painter.save();
     d->painter.setOpacity(0.5);
     d->painter.setCompositionMode(QPainter::CompositionMode_Multiply);
     QRect area(d->xBias, 0, d->pxcols, d->pxrows);
     d->painter.drawPixmap(area,d->gamutMap, area);
     d->painter.setOpacity(1.0);
     d->painter.restore();
 }
 
 void KisCIETongueWidget::updatePixmap()
 {
     d->needUpdatePixmap = false;
     d->pixmap = QPixmap(size());
 
     if (d->cieTongueNeedsUpdate){
     // Draw the CIE tongue curve. I don't see why we need to redraw it every time the whitepoint and such changes so we cache it.
         d->cieTongueNeedsUpdate = false;
         d->cietongue = QPixmap(size());
         d->cietongue.fill(Qt::black);
         d->painter.begin(&d->cietongue);
  
         int pixcols = d->pixmap.width();
         int pixrows = d->pixmap.height();
 
         d->gridside = (qMin(pixcols, pixrows)) / 512.0;
         d->xBias    = grids(32);
         d->yBias    = grids(20);
         d->pxcols   = pixcols - d->xBias;
         d->pxrows   = pixrows - d->yBias;
 
         d->painter.setBackground(QBrush(qRgb(0, 0, 0)));
         d->painter.setPen(qRgb(255, 255, 255));
 
         outlineTongue();
         d->painter.end();
     
         fillTongue();
     
         d->painter.begin(&d->cietongue);
         drawTongueAxis();
         drawLabels();
         drawTongueGrid();
         d->painter.end();
     }
     d->pixmap = d->cietongue;
 
     d->painter.begin(&d->pixmap);
     //draw whitepoint and  colorants
     if (d->whitePoint[2] > 0.0)
     {
         drawWhitePoint();
     }
  
     if (d->Primaries[2] != 0.0)
     {
         drawColorantTriangle();
     }
     drawGamut();
 
     d->painter.end();
 }
  
 void KisCIETongueWidget::paintEvent(QPaintEvent*)
 {
     QPainter p(this);
  
     // Widget is disable : drawing grayed frame.
  
     if ( !isEnabled() )
     {
         p.fillRect(0, 0, width(), height(),
                    palette().color(QPalette::Disabled, QPalette::Background));
  
         QPen pen(palette().color(QPalette::Disabled, QPalette::Foreground));
         pen.setStyle(Qt::SolidLine);
         pen.setWidth(1);
  
         p.setPen(pen);
         p.drawRect(0, 0, width(), height());
  
         return;
     }
 
  
     // No profile data to show, or RAW file
  
     if (!d->profileDataAvailable)
     {
         p.fillRect(0, 0, width(), height(), palette().color(QPalette::Active, QPalette::Background));
         QPen pen(palette().color(QPalette::Active, QPalette::Text));
         pen.setStyle(Qt::SolidLine);
         pen.setWidth(1);
  
         p.setPen(pen);
         p.drawRect(0, 0, width(), height());
  
         if (d->uncalibratedColor)
         {
             p.drawText(0, 0, width(), height(), Qt::AlignCenter,
                        i18n("Uncalibrated color space"));
         }
         else
         {
             p.setPen(Qt::red);
             p.drawText(0, 0, width(), height(), Qt::AlignCenter,
                        i18n("No profile available..."));
         }
  
         return;
     }
  
     // Create CIE tongue if needed
     if (d->needUpdatePixmap)
     {
         updatePixmap();
     }
  
     // draw prerendered tongue
     p.drawPixmap(0, 0, d->pixmap);
 }
  
 void KisCIETongueWidget::resizeEvent(QResizeEvent* event)
 {
     Q_UNUSED(event);
     setMinimumHeight(width());
     setMaximumHeight(width());
     d->needUpdatePixmap = true;
     d->cieTongueNeedsUpdate = true;
 }
  
 void KisCIETongueWidget::slotProgressTimerDone()
 {
     update();
     d->progressTimer->start(200);
 }
diff --git a/libs/ui/widgets/kis_color_space_selector.cc b/libs/ui/widgets/kis_color_space_selector.cc
index 0896d42ebd..870c115705 100644
--- a/libs/ui/widgets/kis_color_space_selector.cc
+++ b/libs/ui/widgets/kis_color_space_selector.cc
@@ -1,275 +1,274 @@
 /*
  *  Copyright (C) 2007 Cyrille Berger <cberger@cberger.net>
  *  Copyright (C) 2011 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@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_color_space_selector.h"
 #include "kis_advanced_color_space_selector.h"
 
 
 #include <QUrl>
 
 #include <KoFileDialog.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoID.h>
 
 #include <KoConfig.h>
 #include <kis_icon.h>
 
 #include <QDesktopServices>
 
 #include <KoResourcePaths.h>
 
 
 #include <kis_debug.h>
 
 #include "ui_wdgcolorspaceselector.h"
 
 struct KisColorSpaceSelector::Private {
     Ui_WdgColorSpaceSelector* colorSpaceSelector;
     QString knsrcFile;
     bool profileValid;
     QString defaultsuffix;
 };
 
 KisColorSpaceSelector::KisColorSpaceSelector(QWidget* parent) : QWidget(parent), m_advancedSelector(0), d(new Private)
 {
     setObjectName("KisColorSpaceSelector");
     d->colorSpaceSelector = new Ui_WdgColorSpaceSelector;
     d->colorSpaceSelector->setupUi(this);
     d->colorSpaceSelector->cmbColorModels->setIDList(KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::OnlyUserVisible));
     fillCmbDepths(d->colorSpaceSelector->cmbColorModels->currentItem());
 
     d->colorSpaceSelector->bnInstallProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     d->colorSpaceSelector->bnInstallProfile->setToolTip( i18n("Open Color Profile") );
 
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(const KoID &)),
             this, SLOT(fillCmbDepths(const KoID &)));
     connect(d->colorSpaceSelector->cmbColorDepth, SIGNAL(activated(const KoID &)),
             this, SLOT(fillCmbProfiles()));
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(const KoID &)),
             this, SLOT(fillCmbProfiles()));
     connect(d->colorSpaceSelector->cmbProfile, SIGNAL(activated(const QString &)),
             this, SLOT(colorSpaceChanged()));
     connect(d->colorSpaceSelector->bnInstallProfile, SIGNAL(clicked()),
             this, SLOT(installProfile()));
 
     d->defaultsuffix = " "+i18nc("This is appended to the color profile which is the default for the given colorspace and bit-depth","(Default)");
 
     connect(d->colorSpaceSelector->bnAdvanced, SIGNAL(clicked()), this,  SLOT(slotOpenAdvancedSelector()));
 
     fillCmbProfiles();
 }
 
 KisColorSpaceSelector::~KisColorSpaceSelector()
 {
     delete d->colorSpaceSelector;
     delete d;
 }
 
 
 void KisColorSpaceSelector::fillCmbProfiles()
 {
-    QString s = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
-    d->colorSpaceSelector->cmbProfile->clear();
+    const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
+    const QString defaultProfileName = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId);
 
-    const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
-    if (csf == 0) return;
+    d->colorSpaceSelector->cmbProfile->clear();
 
-    QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
+    QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId);
     QStringList profileNames;
     Q_FOREACH (const KoColorProfile *profile, profileList) {
         profileNames.append(profile->name());
     }
     qSort(profileNames);
     Q_FOREACH (QString stringName, profileNames) {
-        if (stringName==csf->defaultProfile()) {
-            d->colorSpaceSelector->cmbProfile->addSqueezedItem(stringName+d->defaultsuffix);
+        if (stringName == defaultProfileName) {
+            d->colorSpaceSelector->cmbProfile->addSqueezedItem(stringName + d->defaultsuffix);
         } else {
             d->colorSpaceSelector->cmbProfile->addSqueezedItem(stringName);
         }
     }
-    d->colorSpaceSelector->cmbProfile->setCurrent(csf->defaultProfile()+d->defaultsuffix);
+    d->colorSpaceSelector->cmbProfile->setCurrent(defaultProfileName + d->defaultsuffix);
     colorSpaceChanged();
 }
 
 void KisColorSpaceSelector::fillCmbDepths(const KoID& id)
 {
     KoID activeDepth = d->colorSpaceSelector->cmbColorDepth->currentItem();
     d->colorSpaceSelector->cmbColorDepth->clear();
     QList<KoID> depths = KoColorSpaceRegistry::instance()->colorDepthList(id, KoColorSpaceRegistry::OnlyUserVisible);
 
     // order the depth by name
     qSort(depths.begin(), depths.end(), sortBitDepthsComparer);
 
     d->colorSpaceSelector->cmbColorDepth->setIDList(depths);
     if (depths.contains(activeDepth)) {
         d->colorSpaceSelector->cmbColorDepth->setCurrent(activeDepth);
     }
 }
 
 
 bool KisColorSpaceSelector::sortBitDepthsComparer(KoID depthOne, KoID depthTwo) {
 
     // to order these right, we need to first order by bit depth, then by if it is floating or not
     QString bitDepthOne = depthOne.name().split(" ")[0];
     QString bitDepthTwo = depthTwo.name().split(" ")[0];
 
 
     if (bitDepthOne.toInt() > bitDepthTwo.toInt()) {
         return false;
     }
 
     if (bitDepthOne.toInt() == bitDepthTwo.toInt()) {
         // bit depth number is the same, so now we need to compare if it is a floating type or not
         // the second value [1], just says 'bits', so that is why we look for [2] which has the float word
         QString bitDepthOneType = "";
         QString bitDepthTwoType = "";
 
         if (depthOne.name().split(" ").length() > 2) {
             bitDepthOneType = depthOne.name().split(" ")[2];
         }
         if (depthTwo.name().split(" ").length() > 2) {
             bitDepthTwoType = depthTwo.name().split(" ")[2];
         }
 
         if (bitDepthOneType.length() > bitDepthTwoType.length()) {
             return false;
         }
     }
 
 
     return true;
 }
 
 
 const KoColorSpace* KisColorSpaceSelector::currentColorSpace()
 {
     QString profilenamestring = d->colorSpaceSelector->cmbProfile->itemHighlighted();
     if (profilenamestring.contains(d->defaultsuffix)) {
         profilenamestring.remove(d->defaultsuffix);
         return KoColorSpaceRegistry::instance()->colorSpace(
                     d->colorSpaceSelector->cmbColorModels->currentItem().id(),
                     d->colorSpaceSelector->cmbColorDepth->currentItem().id(),
                     profilenamestring);
     } else {
         return KoColorSpaceRegistry::instance()->colorSpace(
                     d->colorSpaceSelector->cmbColorModels->currentItem().id(),
                     d->colorSpaceSelector->cmbColorDepth->currentItem().id(),
                     profilenamestring);
     }
 }
 
 void KisColorSpaceSelector::setCurrentColorModel(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorModels->setCurrent(id);
     fillCmbDepths(id);
 }
 
 void KisColorSpaceSelector::setCurrentColorDepth(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorDepth->setCurrent(id);
     fillCmbProfiles();
 }
 
 void KisColorSpaceSelector::setCurrentProfile(const QString& name)
 {
     d->colorSpaceSelector->cmbProfile->setCurrent(name);
 }
 
 void KisColorSpaceSelector::setCurrentColorSpace(const KoColorSpace* colorSpace)
 {
     if (!colorSpace) {
         return;
     }
     setCurrentColorModel(colorSpace->colorModelId());
     setCurrentColorDepth(colorSpace->colorDepthId());
     setCurrentProfile(colorSpace->profile()->name());
 }
 
 void KisColorSpaceSelector::showColorBrowserButton(bool showButton) {
     d->colorSpaceSelector->bnAdvanced->setVisible(showButton);
 }
 
 void KisColorSpaceSelector::colorSpaceChanged()
 {
     bool valid = d->colorSpaceSelector->cmbProfile->count() != 0;
     d->profileValid = valid;
     emit(selectionChanged(valid));
     if(valid) {
         emit colorSpaceChanged(currentColorSpace());
         QString text = currentColorSpace()->profile()->name();
     }
 }
 
 void KisColorSpaceSelector::installProfile()
 {
     QStringList mime;
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::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) {
         QUrl file(profileName);
         if (!QFile::copy(profileName, saveLocation + file.fileName())) {
             dbgKrita << "Could not install profile!";
             return;
         }
         iccEngine->addProfile(saveLocation + file.fileName());
 
     }
 
     fillCmbProfiles();
 }
 
 void KisColorSpaceSelector::slotOpenAdvancedSelector()
 {
     if (!m_advancedSelector) {
         m_advancedSelector = new KisAdvancedColorSpaceSelector(this, "Select a Colorspace");
         m_advancedSelector->setModal(true);
         if (currentColorSpace()) {
             m_advancedSelector->setCurrentColorSpace(currentColorSpace());
         }
         connect(m_advancedSelector, SIGNAL(selectionChanged(bool)), this, SLOT(slotProfileValid(bool)) );
     }
 
     QDialog::DialogCode result = (QDialog::DialogCode)m_advancedSelector->exec();
 
     if (result) {
         if (d->profileValid==true) {
             setCurrentColorSpace(m_advancedSelector->currentColorSpace());
         }
     }
 }
 
 void KisColorSpaceSelector::slotProfileValid(bool valid)
 {
     d->profileValid = valid;
 }
 
diff --git a/plugins/color/lcms2engine/tests/TestKoColorSpaceRegistry.cpp b/plugins/color/lcms2engine/tests/TestKoColorSpaceRegistry.cpp
index ac3ee61a46..5837e16151 100644
--- a/plugins/color/lcms2engine/tests/TestKoColorSpaceRegistry.cpp
+++ b/plugins/color/lcms2engine/tests/TestKoColorSpaceRegistry.cpp
@@ -1,95 +1,89 @@
 
 #include "TestKoColorSpaceRegistry.h"
 
 #include <QTest>
 
 #include "KoColorSpaceRegistry.h"
 #include "KoColorSpace.h"
 #include "RgbU8ColorSpace.h"
 #include "RgbU16ColorSpace.h"
 #include "LabColorSpace.h"
 
 void TestKoColorSpaceRegistry::testConstruction()
 {
     KoColorSpaceRegistry *instance = KoColorSpaceRegistry::instance();
     Q_ASSERT(instance);
 }
 
 void TestKoColorSpaceRegistry::testRgbU8()
 {
-    QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(RGBAColorModelID,
-                           Integer8BitsColorDepthID);
-    const KoColorSpaceFactory *colorSpaceFactory = KoColorSpaceRegistry::instance()->colorSpaceFactory(colorSpaceId);
-    QVERIFY(colorSpaceFactory != 0);
+    const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(RGBAColorModelID,
+                                                                                Integer8BitsColorDepthID);
 
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     QVERIFY(colorSpace != 0);
 
     const KoColorProfile *profile = colorSpace->profile();
     QVERIFY(profile != 0);
 
-    QCOMPARE(profile->name(), colorSpaceFactory->defaultProfile());
+    QCOMPARE(profile->name(), KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId));
 
     cmsHPROFILE lcmsProfile = cmsCreate_sRGBProfile();
     QString testProfileName = "TestRGBU8ProfileName";
 
     cmsWriteTag(lcmsProfile, cmsSigProfileDescriptionTag, testProfileName.toLatin1().constData());
     cmsWriteTag(lcmsProfile, cmsSigDeviceModelDescTag, testProfileName.toLatin1().constData());
     cmsWriteTag(lcmsProfile, cmsSigDeviceMfgDescTag, "");
 
 }
 
 void TestKoColorSpaceRegistry::testRgbU16()
 {
-    QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(RGBAColorModelID,
-                           Integer16BitsColorDepthID);
-    const KoColorSpaceFactory *colorSpaceFactory = KoColorSpaceRegistry::instance()->colorSpaceFactory(colorSpaceId);
-    QVERIFY(colorSpaceFactory != 0);
+    const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(RGBAColorModelID,
+                                                                                Integer16BitsColorDepthID);
 
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb16();
     QVERIFY(colorSpace != 0);
 
     const KoColorProfile *profile = colorSpace->profile();
     QVERIFY(profile != 0);
 
-    QCOMPARE(profile->name(), colorSpaceFactory->defaultProfile());
+    QCOMPARE(profile->name(), KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId));
 
     cmsHPROFILE lcmsProfile = cmsCreate_sRGBProfile();
     QString testProfileName = "TestRGBU16ProfileName";
 
     cmsWriteTag(lcmsProfile, cmsSigProfileDescriptionTag, testProfileName.toLatin1().constData());
     cmsWriteTag(lcmsProfile, cmsSigDeviceModelDescTag, testProfileName.toLatin1().constData());
     cmsWriteTag(lcmsProfile, cmsSigDeviceMfgDescTag, "");
 
 }
 
 void TestKoColorSpaceRegistry::testLab()
 {
-    QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(LABAColorModelID,
-                           Integer16BitsColorDepthID);
-    const KoColorSpaceFactory *colorSpaceFactory = KoColorSpaceRegistry::instance()->colorSpaceFactory(colorSpaceId);
-    QVERIFY(colorSpaceFactory != 0);
+    const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(LABAColorModelID,
+                                                                                Integer16BitsColorDepthID);
 
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->lab16();
     QVERIFY(colorSpace != 0);
 
     const KoColorProfile *profile = colorSpace->profile();
     QVERIFY(profile != 0);
 
-    QCOMPARE(profile->name(), colorSpaceFactory->defaultProfile());
+    QCOMPARE(profile->name(), KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId));
 
     cmsCIExyY whitepoint;
     whitepoint.x = 0.33;
     whitepoint.y = 0.33;
     whitepoint.Y = 1.0;
 
     cmsHPROFILE lcmsProfile = cmsCreateLab2Profile(&whitepoint);
     QString testProfileName = "TestLabProfileName";
 
     cmsWriteTag(lcmsProfile, cmsSigProfileDescriptionTag, testProfileName.toLatin1().constData());
     cmsWriteTag(lcmsProfile, cmsSigDeviceModelDescTag, testProfileName.toLatin1().constData());
     cmsWriteTag(lcmsProfile, cmsSigDeviceMfgDescTag, "");
 
 }
 
 QTEST_GUILESS_MAIN(TestKoColorSpaceRegistry)
diff --git a/plugins/impex/jpeg/kis_jpeg_converter.cc b/plugins/impex/jpeg/kis_jpeg_converter.cc
index f6ddbb7c46..6435bf0d4f 100644
--- a/plugins/impex/jpeg/kis_jpeg_converter.cc
+++ b/plugins/impex/jpeg/kis_jpeg_converter.cc
@@ -1,731 +1,732 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  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_jpeg_converter.h"
 
 #include <stdio.h>
 #include <stdint.h>
 
 #include <KoConfig.h>
 #ifdef HAVE_LCMS2
 #   include <lcms2.h>
 #else
 #   include <lcms.h>
 #endif
 
 extern "C" {
 #include <iccjpeg.h>
 }
 
 #include <exiv2/jpgimage.hpp>
 
 #include <QFile>
 #include <QBuffer>
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <QFileInfo>
 
 #include <KoDocumentInfo.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 #include "KoColorModelStandardIds.h"
 
 #include <kis_painter.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include <kis_transaction.h>
 #include <kis_group_layer.h>
 #include <metadata/kis_meta_data_entry.h>
 #include <metadata/kis_meta_data_value.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include <kis_paint_device.h>
 #include <kis_transform_worker.h>
 #include <kis_jpeg_source.h>
 #include <kis_jpeg_destination.h>
 #include "kis_iterator_ng.h"
 
 #include <KoColorModelStandardIds.h>
 
 #define ICC_MARKER  (JPEG_APP0 + 2) /* JPEG marker code for ICC */
 #define ICC_OVERHEAD_LEN  14    /* size of non-profile data in APP2 */
 #define MAX_BYTES_IN_MARKER  65533  /* maximum data len of a JPEG marker */
 #define MAX_DATA_BYTES_IN_MARKER  (MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN)
 
 const char photoshopMarker[] = "Photoshop 3.0\0";
 //const char photoshopBimId_[] = "8BIM";
 const uint16_t photoshopIptc = 0x0404;
 const char xmpMarker[] = "http://ns.adobe.com/xap/1.0/\0";
 const QByteArray photoshopIptc_((char*)&photoshopIptc, 2);
 
 namespace
 {
 
 void jpegErrorExit ( j_common_ptr cinfo )
 {
     char jpegLastErrorMsg[JMSG_LENGTH_MAX];
     /* Create the message */
     ( *( cinfo->err->format_message ) ) ( cinfo, jpegLastErrorMsg );
 
     /* Jump to the setjmp point */
     throw std::runtime_error( jpegLastErrorMsg ); // or your preffered exception ...
 }
 
 J_COLOR_SPACE getColorTypeforColorSpace(const KoColorSpace * cs)
 {
     if (KoID(cs->id()) == KoID("GRAYA") || cs->id() == "GRAYAU16" || cs->id() == "GRAYA16") {
         return JCS_GRAYSCALE;
     }
     if (KoID(cs->id()) == KoID("RGBA") || KoID(cs->id()) == KoID("RGBA16")) {
         return JCS_RGB;
     }
     if (KoID(cs->id()) == KoID("CMYK") || KoID(cs->id()) == KoID("CMYKAU16")) {
         return JCS_CMYK;
     }
     return JCS_UNKNOWN;
 }
 
 QString getColorSpaceModelForColorType(J_COLOR_SPACE color_type)
 {
     dbgFile << "color_type =" << color_type;
     if (color_type == JCS_GRAYSCALE) {
         return GrayAColorModelID.id();
     } else if (color_type == JCS_RGB) {
         return RGBAColorModelID.id();
     } else if (color_type == JCS_CMYK) {
         return CMYKAColorModelID.id();
     }
     return "";
 }
 
 }
 
 struct KisJPEGConverter::Private
 {
     Private(KisDocument *doc, bool batchMode)
         : doc(doc),
           stop(false),
           batchMode(batchMode)
     {}
 
     KisImageSP image;
     KisDocument *doc;
     bool stop;
     bool batchMode;
 };
 
 KisJPEGConverter::KisJPEGConverter(KisDocument *doc, bool batchMode)
     : m_d(new Private(doc, batchMode))
 {
 }
 
 KisJPEGConverter::~KisJPEGConverter()
 {
 }
 
 KisImageBuilder_Result KisJPEGConverter::decode(QIODevice *io)
 {
     struct jpeg_decompress_struct cinfo;
     struct jpeg_error_mgr jerr;
 
     cinfo.err = jpeg_std_error(&jerr);
     jerr.error_exit = jpegErrorExit;
 
     try {
         jpeg_create_decompress(&cinfo);
 
         KisJPEGSource::setSource(&cinfo, io);
 
         jpeg_save_markers(&cinfo, JPEG_COM, 0xFFFF);
         /* Save APP0..APP15 markers */
         for (int m = 0; m < 16; m++)
             jpeg_save_markers(&cinfo, JPEG_APP0 + m, 0xFFFF);
 
 
         //     setup_read_icc_profile(&cinfo);
         // read header
         jpeg_read_header(&cinfo, (boolean)true);
 
         // start reading
         jpeg_start_decompress(&cinfo);
 
         // Get the colorspace
         QString modelId = getColorSpaceModelForColorType(cinfo.out_color_space);
         if (modelId.isEmpty()) {
             dbgFile << "unsupported colorspace :" << cinfo.out_color_space;
             jpeg_destroy_decompress(&cinfo);
             return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
         }
         uchar* profile_data;
         uint profile_len;
         const KoColorProfile* profile = 0;
         QByteArray profile_rawdata;
         if (read_icc_profile(&cinfo, &profile_data, &profile_len)) {
             profile_rawdata.resize(profile_len);
             memcpy(profile_rawdata.data(), profile_data, profile_len);
             cmsHPROFILE hProfile = cmsOpenProfileFromMem(profile_data, profile_len);
 
             if (hProfile != (cmsHPROFILE) 0) {
                 profile = KoColorSpaceRegistry::instance()->createColorProfile(modelId, Integer8BitsColorDepthID.id(), profile_rawdata);
                 Q_CHECK_PTR(profile);
                 dbgFile <<"profile name:" << profile->name() <<" product information:" << profile->info();
                 if (!profile->isSuitableForOutput()) {
                     dbgFile << "the profile is not suitable for output and therefore cannot be used in krita, we need to convert the image to a standard profile"; // TODO: in ko2 popup a selection menu to inform the user
                 }
             }
         }
 
+        const QString colorSpaceId =
+            KoColorSpaceRegistry::instance()->colorSpaceId(modelId, Integer8BitsColorDepthID.id());
+
         // Check that the profile is used by the color space
-        if (profile && !KoColorSpaceRegistry::instance()->colorSpaceFactory(
-                    KoColorSpaceRegistry::instance()->colorSpaceId(
-                        modelId, Integer8BitsColorDepthID.id()))->profileIsCompatible(profile)) {
+        if (profile && !KoColorSpaceRegistry::instance()->profileIsCompatible(profile, colorSpaceId)) {
             warnFile << "The profile " << profile->name() << " is not compatible with the color space model " << modelId;
             profile = 0;
         }
 
         // Retrieve a pointer to the colorspace
         const KoColorSpace* cs;
         if (profile && profile->isSuitableForOutput()) {
             dbgFile << "image has embedded profile:" << profile -> name() << "";
             cs = KoColorSpaceRegistry::instance()->colorSpace(modelId, Integer8BitsColorDepthID.id(), profile);
         } else
             cs = KoColorSpaceRegistry::instance()->colorSpace(modelId, Integer8BitsColorDepthID.id(), "");
 
         if (cs == 0) {
             dbgFile << "unknown colorspace";
             jpeg_destroy_decompress(&cinfo);
             return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
         }
         // TODO fixit
         // Create the cmsTransform if needed
 
         KoColorTransformation* transform = 0;
         if (profile && !profile->isSuitableForOutput()) {
             transform = KoColorSpaceRegistry::instance()->colorSpace(modelId, Integer8BitsColorDepthID.id(), profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
         }
         // Apparently an invalid transform was created from the profile. See bug https://bugs.kde.org/show_bug.cgi?id=255451.
         // After 2.3: warn the user!
         if (transform && !transform->isValid()) {
             delete transform;
             transform = 0;
         }
 
         // Creating the KisImageSP
         if (!m_d->image) {
             m_d->image = new KisImage(m_d->doc->createUndoStore(),  cinfo.image_width,  cinfo.image_height, cs, "built image");
             Q_CHECK_PTR(m_d->image);
         }
 
         // Set resolution
         double xres = 72, yres = 72;
         if (cinfo.density_unit == 1) {
             xres = cinfo.X_density;
             yres = cinfo.Y_density;
         } else if (cinfo.density_unit == 2) {
             xres = cinfo.X_density * 2.54;
             yres = cinfo.Y_density * 2.54;
         }
         if (xres < 72) {
             xres = 72;
         }
         if (yres < 72) {
             yres = 72;
         }
         m_d->image->setResolution(POINT_TO_INCH(xres), POINT_TO_INCH(yres));   // It is the "invert" macro because we convert from pointer-per-inchs to points
 
         // Create layer
         KisPaintLayerSP layer = KisPaintLayerSP(new KisPaintLayer(m_d->image.data(), m_d->image -> nextLayerName(), quint8_MAX));
 
         // Read data
         JSAMPROW row_pointer = new JSAMPLE[cinfo.image_width*cinfo.num_components];
 
         for (; cinfo.output_scanline < cinfo.image_height;) {
             KisHLineIteratorSP it = layer->paintDevice()->createHLineIteratorNG(0, cinfo.output_scanline, cinfo.image_width);
             jpeg_read_scanlines(&cinfo, &row_pointer, 1);
             quint8 *src = row_pointer;
             switch (cinfo.out_color_space) {
             case JCS_GRAYSCALE:
                 do {
                     quint8 *d = it->rawData();
                     d[0] = *(src++);
                     if (transform) transform->transform(d, d, 1);
                     d[1] = quint8_MAX;
 
                 } while (it->nextPixel());
                 break;
             case JCS_RGB:
                 do {
                     quint8 *d = it->rawData();
                     d[2] = *(src++);
                     d[1] = *(src++);
                     d[0] = *(src++);
                     if (transform) transform->transform(d, d, 1);
                     d[3] = quint8_MAX;
 
                 } while (it->nextPixel());
                 break;
             case JCS_CMYK:
                 do {
                     quint8 *d = it->rawData();
                     d[0] = quint8_MAX - *(src++);
                     d[1] = quint8_MAX - *(src++);
                     d[2] = quint8_MAX - *(src++);
                     d[3] = quint8_MAX - *(src++);
                     if (transform) transform->transform(d, d, 1);
                     d[4] = quint8_MAX;
 
                 } while (it->nextPixel());
                 break;
             default:
                 return KisImageBuilder_RESULT_UNSUPPORTED;
             }
         }
 
         m_d->image->addNode(KisNodeSP(layer.data()), m_d->image->rootLayer().data());
 
         // Read exif information
 
         dbgFile << "Looking for exif information";
 
         for (jpeg_saved_marker_ptr marker = cinfo.marker_list; marker != 0; marker = marker->next) {
             dbgFile << "Marker is" << marker->marker;
             if (marker->marker != (JOCTET)(JPEG_APP0 + 1)
                     || marker->data_length < 14) {
                 continue; /* Exif data is in an APP1 marker of at least 14 octets */
             }
 
             if (GETJOCTET(marker->data[0]) != (JOCTET) 0x45 ||
                     GETJOCTET(marker->data[1]) != (JOCTET) 0x78 ||
                     GETJOCTET(marker->data[2]) != (JOCTET) 0x69 ||
                     GETJOCTET(marker->data[3]) != (JOCTET) 0x66 ||
                     GETJOCTET(marker->data[4]) != (JOCTET) 0x00 ||
                     GETJOCTET(marker->data[5]) != (JOCTET) 0x00)
                 continue; /* no Exif header */
             dbgFile << "Found exif information of length :" << marker->data_length;
             KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value("exif");
             Q_ASSERT(exifIO);
             QByteArray byteArray((const char*)marker->data + 6, marker->data_length - 6);
             QBuffer buf(&byteArray);
             exifIO->loadFrom(layer->metaData(), &buf);
             // Interpret orientation tag
             if (layer->metaData()->containsEntry("http://ns.adobe.com/tiff/1.0/", "Orientation")) {
                 KisMetaData::Entry& entry = layer->metaData()->getEntry("http://ns.adobe.com/tiff/1.0/", "Orientation");
                 if (entry.value().type() == KisMetaData::Value::Variant) {
                     switch (entry.value().asVariant().toInt()) {
                     case 2:
                         KisTransformWorker::mirrorY(layer->paintDevice());
                         break;
                     case 3:
                         image()->rotateImage(M_PI);
                         break;
                     case 4:
                         KisTransformWorker::mirrorX(layer->paintDevice());
                         break;
                     case 5:
                         image()->rotateImage(M_PI / 2);
                         KisTransformWorker::mirrorY(layer->paintDevice());
                         break;
                     case 6:
                         image()->rotateImage(M_PI / 2);
                         break;
                     case 7:
                         image()->rotateImage(M_PI / 2);
                         KisTransformWorker::mirrorX(layer->paintDevice());
                         break;
                     case 8:
                         image()->rotateImage(-M_PI / 2 + M_PI*2);
                         break;
                     default:
                         break;
                     }
                 }
                 entry.value().setVariant(1);
             }
             break;
         }
 
         dbgFile << "Looking for IPTC information";
 
         for (jpeg_saved_marker_ptr marker = cinfo.marker_list; marker != 0; marker = marker->next) {
             dbgFile << "Marker is" << marker->marker;
             if (marker->marker != (JOCTET)(JPEG_APP0 + 13) ||  marker->data_length < 14) {
                 continue; /* IPTC data is in an APP13 marker of at least 16 octets */
             }
             if (memcmp(marker->data, photoshopMarker, 14) != 0) {
                 for (int i = 0; i < 14; i++) {
                     dbgFile << (int)(*(marker->data + i)) << "" << (int)(photoshopMarker[i]);
                 }
                 dbgFile << "No photoshop marker";
                 continue; /* No IPTC Header */
             }
 
             dbgFile << "Found Photoshop information of length :" << marker->data_length;
             KisMetaData::IOBackend* iptcIO = KisMetaData::IOBackendRegistry::instance()->value("iptc");
             Q_ASSERT(iptcIO);
             const Exiv2::byte *record = 0;
             uint32_t sizeIptc = 0;
             uint32_t sizeHdr = 0;
             // Find actual Iptc data within the APP13 segment
             if (!Exiv2::Photoshop::locateIptcIrb((Exiv2::byte*)(marker->data + 14),
                                                  marker->data_length - 14, &record, &sizeHdr, &sizeIptc)) {
                 if (sizeIptc) {
                     // Decode the IPTC data
                     QByteArray byteArray((const char*)(record + sizeHdr), sizeIptc);
                     iptcIO->loadFrom(layer->metaData(), new QBuffer(&byteArray));
                 } else {
                     dbgFile << "IPTC Not found in Photoshop marker";
                 }
             }
             break;
         }
 
         dbgFile << "Looking for XMP information";
 
         for (jpeg_saved_marker_ptr marker = cinfo.marker_list; marker != 0; marker = marker->next) {
             dbgFile << "Marker is" << marker->marker;
             if (marker->marker != (JOCTET)(JPEG_APP0 + 1) || marker->data_length < 31) {
                 continue; /* XMP data is in an APP1 marker of at least 31 octets */
             }
             if (memcmp(marker->data, xmpMarker, 29) != 0) {
                 dbgFile << "Not XMP marker";
                 continue; /* No xmp Header */
             }
             dbgFile << "Found XMP Marker of length " << marker->data_length;
             QByteArray byteArray((const char*)marker->data + 29, marker->data_length - 29);
             KisMetaData::IOBackend* xmpIO = KisMetaData::IOBackendRegistry::instance()->value("xmp");
             Q_ASSERT(xmpIO);
             xmpIO->loadFrom(layer->metaData(), new QBuffer(&byteArray));
             break;
         }
 
         // Dump loaded metadata
         layer->metaData()->debugDump();
 
         // Check whether the metadata has resolution info, too...
         if (cinfo.density_unit == 0 && layer->metaData()->containsEntry("tiff:XResolution") && layer->metaData()->containsEntry("tiff:YResolution")) {
             double xres = layer->metaData()->getEntry("tiff:XResolution").value().asDouble();
             double yres = layer->metaData()->getEntry("tiff:YResolution").value().asDouble();
             if (xres != 0 && yres != 0) {
                 m_d->image->setResolution(POINT_TO_INCH(xres), POINT_TO_INCH(yres));   // It is the "invert" macro because we convert from pointer-per-inchs to points
             }
         }
 
         // Finish decompression
         jpeg_finish_decompress(&cinfo);
         jpeg_destroy_decompress(&cinfo);
         delete [] row_pointer;
         return KisImageBuilder_RESULT_OK;
     }
     catch( std::runtime_error &e) {
         jpeg_destroy_decompress(&cinfo);
         return KisImageBuilder_RESULT_FAILURE;
     }
 }
 
 
 
 KisImageBuilder_Result KisJPEGConverter::buildImage(QIODevice *io)
 {
     return decode(io);
 }
 
 
 KisImageSP KisJPEGConverter::image()
 {
     return m_d->image;
 }
 
 
 KisImageBuilder_Result KisJPEGConverter::buildFile(QIODevice *io, KisPaintLayerSP layer, KisJPEGOptions options, KisMetaData::Store* metaData)
 {
     if (!layer)
         return KisImageBuilder_RESULT_INVALID_ARG;
 
     KisImageSP image = KisImageSP(layer->image());
     if (!image)
         return KisImageBuilder_RESULT_EMPTY;
 
     const KoColorSpace * cs = layer->colorSpace();
     J_COLOR_SPACE color_type = getColorTypeforColorSpace(cs);
 
     if (color_type == JCS_UNKNOWN) {
         KUndo2Command *tmp = layer->paintDevice()->convertTo(KoColorSpaceRegistry::instance()->rgb8(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
         delete tmp;
         cs = KoColorSpaceRegistry::instance()->rgb8();
         color_type = JCS_RGB;
     }
 
     if (options.forceSRGB) {
         const KoColorSpace* dst = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), layer->colorSpace()->colorDepthId().id(), "sRGB built-in - (lcms internal)");
         KUndo2Command *tmp = layer->paintDevice()->convertTo(dst);
         delete tmp;
         cs = dst;
         color_type = JCS_RGB;
     }
 
     uint height = image->height();
     uint width = image->width();
     // Initialize structure
     struct jpeg_compress_struct cinfo;
     // Initialize error output
     struct jpeg_error_mgr jerr;
     cinfo.err = jpeg_std_error(&jerr);
     jpeg_create_compress(&cinfo);
     // Initialize output stream
     KisJPEGDestination::setDestination(&cinfo, io);
 
     cinfo.image_width = width;  // image width and height, in pixels
     cinfo.image_height = height;
     cinfo.input_components = cs->colorChannelCount(); // number of color channels per pixel */
     cinfo.in_color_space = color_type;   // colorspace of input image
 
     // Set default compression parameters
     jpeg_set_defaults(&cinfo);
     // Customize them
     jpeg_set_quality(&cinfo, options.quality, (boolean)options.baseLineJPEG);
 
     if (options.progressive) {
         jpeg_simple_progression(&cinfo);
     }
     // Optimize ?
     cinfo.optimize_coding = (boolean)options.optimize;
 
     // Smoothing
     cinfo.smoothing_factor = (boolean)options.smooth;
 
     // Subsampling
     switch (options.subsampling) {
     default:
     case 0: {
         cinfo.comp_info[0].h_samp_factor = 2;
         cinfo.comp_info[0].v_samp_factor = 2;
         cinfo.comp_info[1].h_samp_factor = 1;
         cinfo.comp_info[1].v_samp_factor = 1;
         cinfo.comp_info[2].h_samp_factor = 1;
         cinfo.comp_info[2].v_samp_factor = 1;
 
     }
         break;
     case 1: {
         cinfo.comp_info[0].h_samp_factor = 2;
         cinfo.comp_info[0].v_samp_factor = 1;
         cinfo.comp_info[1].h_samp_factor = 1;
         cinfo.comp_info[1].v_samp_factor = 1;
         cinfo.comp_info[2].h_samp_factor = 1;
         cinfo.comp_info[2].v_samp_factor = 1;
     }
         break;
     case 2: {
         cinfo.comp_info[0].h_samp_factor = 1;
         cinfo.comp_info[0].v_samp_factor = 2;
         cinfo.comp_info[1].h_samp_factor = 1;
         cinfo.comp_info[1].v_samp_factor = 1;
         cinfo.comp_info[2].h_samp_factor = 1;
         cinfo.comp_info[2].v_samp_factor = 1;
     }
         break;
     case 3: {
         cinfo.comp_info[0].h_samp_factor = 1;
         cinfo.comp_info[0].v_samp_factor = 1;
         cinfo.comp_info[1].h_samp_factor = 1;
         cinfo.comp_info[1].v_samp_factor = 1;
         cinfo.comp_info[2].h_samp_factor = 1;
         cinfo.comp_info[2].v_samp_factor = 1;
     }
         break;
     }
 
     // Save resolution
     cinfo.X_density = INCH_TO_POINT(image->xRes()); // It is the "invert" macro because we convert from pointer-per-inchs to points
     cinfo.Y_density = INCH_TO_POINT(image->yRes()); // It is the "invert" macro because we convert from pointer-per-inchs to points
     cinfo.density_unit = 1;
     cinfo.write_JFIF_header = (boolean)true;
 
     // Start compression
     jpeg_start_compress(&cinfo, (boolean)true);
     // Save exif and iptc information if any available
 
     if (metaData && !metaData->empty()) {
         metaData->applyFilters(options.filters);
         // Save EXIF
         if (options.exif) {
             dbgFile << "Trying to save exif information";
 
             KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value("exif");
             Q_ASSERT(exifIO);
 
             QBuffer buffer;
             exifIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
 
             dbgFile << "Exif information size is" << buffer.data().size();
             QByteArray data = buffer.data();
             if (data.size() < MAX_DATA_BYTES_IN_MARKER) {
                 jpeg_write_marker(&cinfo, JPEG_APP0 + 1, (const JOCTET*)data.data(), data.size());
             } else {
                 dbgFile << "EXIF information could not be saved."; // TODO: warn the user ?
             }
         }
         // Save IPTC
         if (options.iptc) {
             dbgFile << "Trying to save exif information";
             KisMetaData::IOBackend* iptcIO = KisMetaData::IOBackendRegistry::instance()->value("iptc");
             Q_ASSERT(iptcIO);
 
             QBuffer buffer;
             iptcIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
 
             dbgFile << "IPTC information size is" << buffer.data().size();
             QByteArray data = buffer.data();
             if (data.size() < MAX_DATA_BYTES_IN_MARKER) {
                 jpeg_write_marker(&cinfo, JPEG_APP0 + 13, (const JOCTET*)data.data(), data.size());
             } else {
                 dbgFile << "IPTC information could not be saved."; // TODO: warn the user ?
             }
         }
         // Save XMP
         if (options.xmp) {
             dbgFile << "Trying to save XMP information";
             KisMetaData::IOBackend* xmpIO = KisMetaData::IOBackendRegistry::instance()->value("xmp");
             Q_ASSERT(xmpIO);
 
             QBuffer buffer;
             xmpIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
 
             dbgFile << "XMP information size is" << buffer.data().size();
             QByteArray data = buffer.data();
             if (data.size() < MAX_DATA_BYTES_IN_MARKER) {
                 jpeg_write_marker(&cinfo, JPEG_APP0 + 14, (const JOCTET*)data.data(), data.size());
             } else {
                 dbgFile << "XMP information could not be saved."; // TODO: warn the user ?
             }
         }
     }
 
 
     KisPaintDeviceSP dev = new KisPaintDevice(layer->colorSpace());
     KoColor c(options.transparencyFillColor, layer->colorSpace());
     dev->fill(QRect(0, 0, width, height), c);
     KisPainter gc(dev);
     gc.bitBlt(QPoint(0, 0), layer->paintDevice(), QRect(0, 0, width, height));
     gc.end();
 
 
     if (options.saveProfile) {
         const KoColorProfile* colorProfile = layer->colorSpace()->profile();
         QByteArray colorProfileData = colorProfile->rawData();
         write_icc_profile(& cinfo, (uchar*) colorProfileData.data(), colorProfileData.size());
     }
 
     // Write data information
 
     JSAMPROW row_pointer = new JSAMPLE[width*cinfo.input_components];
     int color_nb_bits = 8 * layer->paintDevice()->pixelSize() / layer->paintDevice()->channelCount();
 
     for (; cinfo.next_scanline < height;) {
         KisHLineConstIteratorSP it = dev->createHLineConstIteratorNG(0, cinfo.next_scanline, width);
         quint8 *dst = row_pointer;
         switch (color_type) {
         case JCS_GRAYSCALE:
             if (color_nb_bits == 16) {
                 do {
                     //const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     const quint8 *d = it->oldRawData();
                     *(dst++) = cs->scaleToU8(d, 0);//d[0] / quint8_MAX;
 
                 } while (it->nextPixel());
             } else {
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[0];
 
                 } while (it->nextPixel());
             }
             break;
         case JCS_RGB:
             if (color_nb_bits == 16) {
                 do {
                     //const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     const quint8 *d = it->oldRawData();
                     *(dst++) = cs->scaleToU8(d, 2); //d[2] / quint8_MAX;
                     *(dst++) = cs->scaleToU8(d, 1); //d[1] / quint8_MAX;
                     *(dst++) = cs->scaleToU8(d, 0); //d[0] / quint8_MAX;
 
                 } while (it->nextPixel());
             } else {
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
 
                 } while (it->nextPixel());
             }
             break;
         case JCS_CMYK:
             if (color_nb_bits == 16) {
                 do {
                     //const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     const quint8 *d = it->oldRawData();
                     *(dst++) = quint8_MAX - cs->scaleToU8(d, 0);//quint8_MAX - d[0] / quint8_MAX;
                     *(dst++) = quint8_MAX - cs->scaleToU8(d, 1);//quint8_MAX - d[1] / quint8_MAX;
                     *(dst++) = quint8_MAX - cs->scaleToU8(d, 2);//quint8_MAX - d[2] / quint8_MAX;
                     *(dst++) = quint8_MAX - cs->scaleToU8(d, 3);//quint8_MAX - d[3] / quint8_MAX;
 
                 } while (it->nextPixel());
             } else {
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = quint8_MAX - d[0];
                     *(dst++) = quint8_MAX - d[1];
                     *(dst++) = quint8_MAX - d[2];
                     *(dst++) = quint8_MAX - d[3];
 
                 } while (it->nextPixel());
             }
             break;
         default:
             delete [] row_pointer;
             jpeg_destroy_compress(&cinfo);
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
         jpeg_write_scanlines(&cinfo, &row_pointer, 1);
     }
 
 
     // Writing is over
     jpeg_finish_compress(&cinfo);
 
     delete [] row_pointer;
     // Free memory
     jpeg_destroy_compress(&cinfo);
 
     return KisImageBuilder_RESULT_OK;
 }
 
 
 void KisJPEGConverter::cancel()
 {
     m_d->stop = true;
 }
 
 
diff --git a/plugins/impex/libkra/kis_kra_loader.cpp b/plugins/impex/libkra/kis_kra_loader.cpp
index d9fac5a1e8..164d72da9a 100644
--- a/plugins/impex/libkra/kis_kra_loader.cpp
+++ b/plugins/impex/libkra/kis_kra_loader.cpp
@@ -1,1153 +1,1154 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2007
  *
  * 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 "kis_kra_loader.h"
 
 #include <QApplication>
 #include <QStringList>
 
 #include <QMessageBox>
 
 #include <QUrl>
 #include <QBuffer>
 
 #include <KoStore.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorProfile.h>
 #include <KoDocumentInfo.h>
 #include <KoFileDialog.h>
 #include <KisImportExportManager.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <generator/kis_generator.h>
 #include <generator/kis_generator_layer.h>
 #include <generator/kis_generator_registry.h>
 #include <kis_adjustment_layer.h>
 #include <kis_annotation.h>
 #include <kis_base_node.h>
 #include <kis_clone_layer.h>
 #include <kis_debug.h>
 #include <kis_assert.h>
 #include <kis_external_layer_iface.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include "lazybrush/kis_colorize_mask.h"
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_shape_layer.h>
 #include <kis_transparency_mask.h>
 #include <kis_layer_composition.h>
 #include <kis_file_layer.h>
 #include <kis_psd_layer_style.h>
 #include <kis_psd_layer_style_resource.h>
 #include "kis_resource_server_provider.h"
 #include "kis_keyframe_channel.h"
 #include <kis_filter_configuration.h>
 
 #include "KisDocument.h"
 #include "kis_config.h"
 #include "kis_kra_tags.h"
 #include "kis_kra_utils.h"
 #include "kis_kra_load_visitor.h"
 #include "kis_dom_utils.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_config.h"
 #include "KisProofingConfiguration.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_node_view_color_scheme.h"
 
 /*
 
   Color model id comparison through the ages:
 
 2.4        2.5          2.6         ideal
 
 ALPHA      ALPHA        ALPHA       ALPHAU8
 
 CMYK       CMYK         CMYK        CMYKAU8
            CMYKAF32     CMYKAF32
 CMYKA16    CMYKAU16     CMYKAU16
 
 GRAYA      GRAYA        GRAYA       GRAYAU8
 GrayF32    GRAYAF32     GRAYAF32
 GRAYA16    GRAYAU16     GRAYAU16
 
 LABA       LABA         LABA        LABAU16
            LABAF32      LABAF32
            LABAU8       LABAU8
 
 RGBA       RGBA         RGBA        RGBAU8
 RGBA16     RGBA16       RGBA16      RGBAU16
 RgbAF32    RGBAF32      RGBAF32
 RgbAF16    RgbAF16      RGBAF16
 
 XYZA16     XYZA16       XYZA16      XYZAU16
            XYZA8        XYZA8       XYZAU8
 XyzAF16    XyzAF16      XYZAF16
 XyzAF32    XYZAF32      XYZAF32
 
 YCbCrA     YCBCRA8      YCBCRA8     YCBCRAU8
 YCbCrAU16  YCBCRAU16    YCBCRAU16
            YCBCRF32     YCBCRF32
  */
 
 using namespace KRA;
 
 struct KisKraLoader::Private
 {
 public:
 
     KisDocument* document;
     QString imageName; // used to be stored in the image, is now in the documentInfo block
     QString imageComment; // used to be stored in the image, is now in the documentInfo block
     QMap<KisNode*, QString> layerFilenames; // temp storage during loading
     int syntaxVersion; // version of the fileformat we are loading
     vKisNodeSP selectedNodes; // the nodes that were active when saving the document.
     QMap<QString, QString> assistantsFilenames;
     QList<KisPaintingAssistantSP> assistants;
     QMap<KisNode*, QString> keyframeFilenames;
     QStringList errorMessages;
     QStringList warningMessages;
 };
 
 void convertColorSpaceNames(QString &colorspacename, QString &profileProductName) {
     if (colorspacename  == "Grayscale + Alpha") {
         colorspacename  = "GRAYA";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF32") {
         colorspacename = "RGBAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF16") {
         colorspacename = "RGBAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "CMYKA16") {
         colorspacename = "CMYKAU16";
     }
     else if (colorspacename == "GrayF32") {
         colorspacename =  "GRAYAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "GRAYA16") {
         colorspacename  = "GRAYAU16";
     }
     else if (colorspacename == "XyzAF16") {
         colorspacename  = "XYZAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "XyzAF32") {
         colorspacename  = "XYZAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "YCbCrA") {
         colorspacename  = "YCBCRA8";
     }
     else if (colorspacename == "YCbCrAU16") {
         colorspacename  = "YCBCRAU16";
     }
 }
 
 KisKraLoader::KisKraLoader(KisDocument * document, int syntaxVersion)
         : m_d(new Private())
 {
     m_d->document = document;
     m_d->syntaxVersion = syntaxVersion;
 }
 
 
 KisKraLoader::~KisKraLoader()
 {
     delete m_d;
 }
 
 
 KisImageSP KisKraLoader::loadXML(const KoXmlElement& element)
 {
     QString attr;
     KisImageSP image = 0;
     QString name;
     qint32 width;
     qint32 height;
     QString profileProductName;
     double xres;
     double yres;
     QString colorspacename;
     const KoColorSpace * cs;
 
     if ((attr = element.attribute(MIME)) == NATIVE_MIMETYPE) {
 
         if ((m_d->imageName = element.attribute(NAME)).isNull()) {
             m_d->errorMessages << i18n("Image does not have a name.");
             return KisImageSP(0);
         }
 
         if ((attr = element.attribute(WIDTH)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a width.");
             return KisImageSP(0);
         }
         width = KisDomUtils::toInt(attr);
 
         if ((attr = element.attribute(HEIGHT)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a height.");
             return KisImageSP(0);
         }
 
         height = KisDomUtils::toInt(attr);
 
         m_d->imageComment = element.attribute(DESCRIPTION);
 
         xres = 100.0 / 72.0;
         if (!(attr = element.attribute(X_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
 
             if (value > 1.0) {
                 xres = value / 72.0;
             }
         }
 
         yres = 100.0 / 72.0;
         if (!(attr = element.attribute(Y_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
             if (value > 1.0) {
                 yres = value / 72.0;
             }
         }
 
         if ((colorspacename = element.attribute(COLORSPACE_NAME)).isNull()) {
             // An old file: take a reasonable default.
             // Krita didn't support anything else in those
             // days anyway.
             colorspacename = "RGBA";
         }
 
         profileProductName = element.attribute(PROFILE);
         // A hack for an old colorspacename
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
 
         if (profileProductName.isNull()) {
             // no mention of profile so get default profile";
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         } else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, profileProductName);
         }
 
         if (cs == 0) {
             // try once more without the profile
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
             if (cs == 0) {
                 m_d->errorMessages << i18n("Image specifies an unsupported color model: %1.", colorspacename);
                 return KisImageSP(0);
             }
         }
         KisImageConfig cfgImage;
         KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
         if (!(attr = element.attribute(PROOFINGPROFILENAME)).isNull()) {
             proofingConfig->proofingProfile = attr;
         }
         if (!(attr = element.attribute(PROOFINGMODEL)).isNull()) {
             proofingConfig->proofingModel = attr;
         }
         if (!(attr = element.attribute(PROOFINGDEPTH)).isNull()) {
             proofingConfig->proofingDepth = attr;
         }
         if (!(attr = element.attribute(PROOFINGINTENT)).isNull()) {
             proofingConfig->intent = (KoColorConversionTransformation::Intent) KisDomUtils::toInt(attr);
         }
 
         if (!(attr = element.attribute(PROOFINGADAPTATIONSTATE)).isNull()) {
             proofingConfig->adaptationState = KisDomUtils::toDouble(attr);
         }
 
         if (m_d->document) {
             image = new KisImage(m_d->document->createUndoStore(), width, height, cs, name);
         }
         else {
             image = new KisImage(0, width, height, cs, name);
         }
         image->setResolution(xres, yres);
         loadNodes(element, image, const_cast<KisGroupLayer*>(image->rootLayer().data()));
 
 
         KoXmlNode child;
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == CANVASPROJECTIONCOLOR) {
                 if (e.hasAttribute(COLORBYTEDATA)) {
                     QByteArray colorData = QByteArray::fromBase64(e.attribute(COLORBYTEDATA).toLatin1());
                     KoColor color((const quint8*)colorData.data(), image->colorSpace());
                     image->setDefaultProjectionColor(color);
                 }
             }
 
             if(e.tagName()== PROOFINGWARNINGCOLOR) {
                 QDomDocument dom;
                 KoXml::asQDomElement(dom, e);
                 QDomElement eq = dom.firstChildElement();
                 proofingConfig->warningColor = KoColor::fromXML(eq.firstChildElement(), Integer8BitsColorDepthID.id());
             }
 
             if (e.tagName().toLower() == "animation") {
                 loadAnimationMetadata(e, image);
             }
         }
 
         image->setProofingConfiguration(proofingConfig);
 
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == "compositions") {
                 loadCompositions(e, image);
             }
         }
     }
     KoXmlNode child;
 
     for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
         KoXmlElement e = child.toElement();
         if (e.tagName() == "grid") {
             loadGrid(e);
         } else if (e.tagName() == "guides") {
             loadGuides(e);
         } else if (e.tagName() == "assistants") {
             loadAssistantsList(e);
         } else if (e.tagName() == "audio") {
             loadAudio(e, image);
         }
     }
 
     return image;
 }
 
 void KisKraLoader::loadBinaryData(KoStore * store, KisImageSP image, const QString & uri, bool external)
 {
     // icc profile: if present, this overrides the profile product name loaded in loadXML.
     QString location = external ? QString() : uri;
     location += m_d->imageName + ICC_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray data; data.resize(store->size());
             bool res = (store->read(data.data(), store->size()) > -1);
             store->close();
             if (res) {
                 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(image->colorSpace()->colorModelId().id(), image->colorSpace()->colorDepthId().id(), data);
                 if (profile && profile->valid()) {
                     res = image->assignImageProfile(profile);
                 }
                 if (!res) {
-                    profile = KoColorSpaceRegistry::instance()->profileByName(KoColorSpaceRegistry::instance()->colorSpaceFactory(image->colorSpace()->id())->defaultProfile());
+                    const QString defaultProfileId = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(image->colorSpace()->id());
+                    profile = KoColorSpaceRegistry::instance()->profileByName(defaultProfileId);
                     Q_ASSERT(profile && profile->valid());
                     image->assignImageProfile(profile);
                 }
             }
         }
     }
     //load the embed proofing profile, it only needs to be loaded into Krita, not assigned.
     location = external ? QString() : uri;
     location += m_d->imageName + ICC_PROOFING_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray proofingData;
             proofingData.resize(store->size());
             bool proofingProfileRes = (store->read(proofingData.data(), store->size())>-1);
             store->close();
             if (proofingProfileRes)
             {
                 const KoColorProfile *proofingProfile = KoColorSpaceRegistry::instance()->createColorProfile(image->proofingConfiguration()->proofingModel, image->proofingConfiguration()->proofingDepth, proofingData);
                 if (proofingProfile->valid()){
 
                     //if (KoColorSpaceEngineRegistry::instance()->get("icc")) {
                     //    KoColorSpaceEngineRegistry::instance()->get("icc")->addProfile(proofingProfile->fileName());
                     //}
                     KoColorSpaceRegistry::instance()->addProfile(proofingProfile);
                 }
             }
         }
     }
 
 
     // Load the layers data: if there is a profile associated with a layer it will be set now.
     KisKraLoadVisitor visitor(image, store, m_d->layerFilenames, m_d->keyframeFilenames, m_d->imageName, m_d->syntaxVersion);
 
     if (external) {
         visitor.setExternalUri(uri);
     }
 
     image->rootLayer()->accept(visitor);
     if (!visitor.errorMessages().isEmpty()) {
         m_d->errorMessages.append(visitor.errorMessages());
     }
     if (!visitor.warningMessages().isEmpty()) {
         m_d->warningMessages.append(visitor.warningMessages());
     }
 
     // annotations
     // exif
     location = external ? QString() : uri;
     location += m_d->imageName + EXIF_PATH;
     if (store->hasFile(location)) {
         QByteArray data;
         store->open(location);
         data = store->read(store->size());
         store->close();
         image->addAnnotation(KisAnnotationSP(new KisAnnotation("exif", "", data)));
     }
 
 
     // layer styles
     location = external ? QString() : uri;
     location += m_d->imageName + LAYER_STYLES_PATH;
     if (store->hasFile(location)) {
         KisPSDLayerStyleCollectionResource *collection =
             new KisPSDLayerStyleCollectionResource("Embedded Styles.asl");
 
         collection->setName(i18nc("Auto-generated layer style collection name for embedded styles (collection)", "<%1> (embedded)", m_d->imageName));
 
         KIS_ASSERT_RECOVER_NOOP(!collection->valid());
 
         store->open(location);
         {
             KoStoreDevice device(store);
             device.open(QIODevice::ReadOnly);
 
             /**
              * ASL loading code cannot work with non-sequential IO devices,
              * so convert the device beforehand!
              */
             QByteArray buf = device.readAll();
             QBuffer raDevice(&buf);
             raDevice.open(QIODevice::ReadOnly);
             collection->loadFromDevice(&raDevice);
         }
         store->close();
 
         if (collection->valid()) {
             KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
             server->addResource(collection, false);
 
             collection->assignAllLayerStyles(image->root());
         } else {
             warnKrita << "WARNING: Couldn't load layer styles library from .kra!";
             delete collection;
         }
     }
 
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("title").isNull())
         m_d->document->documentInfo()->setAboutInfo("title", m_d->imageName);
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("comment").isNull())
         m_d->document->documentInfo()->setAboutInfo("comment", m_d->imageComment);
 
     loadAssistants(store, uri, external);
 }
 
 vKisNodeSP KisKraLoader::selectedNodes() const
 {
     return m_d->selectedNodes;
 }
 
 QList<KisPaintingAssistantSP> KisKraLoader::assistants() const
 {
     return m_d->assistants;
 }
 
 QStringList KisKraLoader::errorMessages() const
 {
     return m_d->errorMessages;
 }
 
 QStringList KisKraLoader::warningMessages() const
 {
     return m_d->warningMessages;
 }
 
 
 void KisKraLoader::loadAssistants(KoStore *store, const QString &uri, bool external)
 {
     QString file_path;
     QString location;
     QMap<int ,KisPaintingAssistantHandleSP> handleMap;
     KisPaintingAssistant* assistant = 0;
     QMap<QString,QString>::const_iterator loadedAssistant = m_d->assistantsFilenames.constBegin();
     while (loadedAssistant != m_d->assistantsFilenames.constEnd()){
         const KisPaintingAssistantFactory* factory = KisPaintingAssistantFactoryRegistry::instance()->get(loadedAssistant.value());
         if (factory) {
             assistant = factory->createPaintingAssistant();
             location = external ? QString() : uri;
             location += m_d->imageName + ASSISTANTS_PATH;
             file_path = location + loadedAssistant.key();
             assistant->loadXml(store, handleMap, file_path);
             //If an assistant has too few handles than it should according to it's own setup, just don't load it//
             if (assistant->handles().size()==assistant->numHandles()){
                 m_d->assistants.append(toQShared(assistant));
             }
         }
         loadedAssistant++;
     }
 }
 
 void KisKraLoader::loadAnimationMetadata(const KoXmlElement &element, KisImageSP image)
 {
     QDomDocument qDom;
     KoXml::asQDomElement(qDom, element);
     QDomElement qElement = qDom.firstChildElement();
 
     float framerate;
     KisTimeRange range;
     int currentTime;
 
     KisImageAnimationInterface *animation = image->animationInterface();
 
     if (KisDomUtils::loadValue(qElement, "framerate", &framerate)) {
         animation->setFramerate(framerate);
     }
 
     if (KisDomUtils::loadValue(qElement, "range", &range)) {
         animation->setFullClipRange(range);
     }
 
     if (KisDomUtils::loadValue(qElement, "currentTime", &currentTime)) {
         animation->switchCurrentTimeAsync(currentTime);
     }
 }
 
 KisNodeSP KisKraLoader::loadNodes(const KoXmlElement& element, KisImageSP image, KisNodeSP parent)
 {
 
     KoXmlNode node = element.firstChild();
     KoXmlNode child;
 
     if (!node.isNull()) {
 
         if (node.isElement()) {
 
             if (node.nodeName().toUpper() == LAYERS.toUpper() || node.nodeName().toUpper() == MASKS.toUpper()) {
                 for (child = node.lastChild(); !child.isNull(); child = child.previousSibling()) {
                     KisNodeSP node = loadNode(child.toElement(), image, parent);
                     if (node) {
                         image->nextLayerName(); // Make sure the nameserver is current with the number of nodes.
                         image->addNode(node, parent);
                         if (node->inherits("KisLayer") && child.childNodesCount() > 0) {
                             loadNodes(child.toElement(), image, node);
                         }
                     }
                 }
             }
         }
     }
 
     return parent;
 }
 
 KisNodeSP KisKraLoader::loadNode(const KoXmlElement& element, KisImageSP image, KisNodeSP parent)
 {
     // Nota bene: If you add new properties to layers, you should
     // ALWAYS define a default value in case the property is not
     // present in the layer definition: this helps a LOT with backward
     // compatibility.
     QString name = element.attribute(NAME, "No Name");
 
     QUuid id = QUuid(element.attribute(UUID, QUuid().toString()));
 
     qint32 x = element.attribute(X, "0").toInt();
     qint32 y = element.attribute(Y, "0").toInt();
 
     qint32 opacity = element.attribute(OPACITY, QString::number(OPACITY_OPAQUE_U8)).toInt();
     if (opacity < OPACITY_TRANSPARENT_U8) opacity = OPACITY_TRANSPARENT_U8;
     if (opacity > OPACITY_OPAQUE_U8) opacity = OPACITY_OPAQUE_U8;
 
     const KoColorSpace* colorSpace = 0;
     if ((element.attribute(COLORSPACE_NAME)).isNull()) {
         dbgFile << "No attribute color space for layer: " << name;
         colorSpace = image->colorSpace();
     }
     else {
         QString colorspacename = element.attribute(COLORSPACE_NAME);
         QString profileProductName;
 
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
         dbgFile << "Searching color space: " << colorspacename << colorspaceModel << colorspaceDepth << " for layer: " << name;
         // use default profile - it will be replaced later in completeLoading
 
         colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         dbgFile << "found colorspace" << colorSpace;
         if (!colorSpace) {
             m_d->warningMessages << i18n("Layer %1 specifies an unsupported color model: %2.", name, colorspacename);
             return 0;
         }
     }
 
     const bool visible = element.attribute(VISIBLE, "1") == "0" ? false : true;
     const bool locked = element.attribute(LOCKED, "0") == "0" ? false : true;
     const bool collapsed = element.attribute(COLLAPSED, "0") == "0" ? false : true;
     int colorLabelIndex = element.attribute(COLOR_LABEL, "0").toInt();
     QVector<QColor> labels = KisNodeViewColorScheme::instance()->allColorLabels();
     if (colorLabelIndex >= labels.size()) {
         colorLabelIndex = labels.size() - 1;
     }
 
     // Now find out the layer type and do specific handling
     QString nodeType;
 
     if (m_d->syntaxVersion == 1) {
         nodeType = element.attribute("layertype");
         if (nodeType.isEmpty()) {
             nodeType = PAINT_LAYER;
         }
     }
     else {
         nodeType = element.attribute(NODE_TYPE);
     }
 
     if (nodeType.isEmpty()) {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type.", name);
         return 0;
     }
 
 
     KisNodeSP node = 0;
 
     if (nodeType == PAINT_LAYER)
         node = loadPaintLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GROUP_LAYER)
         node = loadGroupLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == ADJUSTMENT_LAYER)
         node = loadAdjustmentLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == SHAPE_LAYER)
         node = loadShapeLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GENERATOR_LAYER)
         node = loadGeneratorLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == CLONE_LAYER)
         node = loadCloneLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == FILTER_MASK)
         node = loadFilterMask(element, parent);
     else if (nodeType == TRANSFORM_MASK)
         node = loadTransformMask(element, parent);
     else if (nodeType == TRANSPARENCY_MASK)
         node = loadTransparencyMask(element, parent);
     else if (nodeType == SELECTION_MASK)
         node = loadSelectionMask(image, element, parent);
     else if (nodeType == COLORIZE_MASK)
         node = loadColorizeMask(image, element, parent, colorSpace);
     else if (nodeType == FILE_LAYER) {
         node = loadFileLayer(element, image, name, opacity);
     }
     else {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type: %2.", name, nodeType);
         return 0;
     }
 
     // Loading the node went wrong. Return empty node and leave to
     // upstream to complain to the user
     if (!node) {
         m_d->warningMessages << i18n("Failure loading layer %1 of type: %2.", name, nodeType);
         return 0;
     }
 
     node->setVisible(visible, true);
     node->setUserLocked(locked);
     node->setCollapsed(collapsed);
     node->setColorLabelIndex(colorLabelIndex);
     node->setX(x);
     node->setY(y);
     node->setName(name);
 
     if (! id.isNull())          // if no uuid in file, new one has been generated already
         node->setUuid(id);
 
     if (node->inherits("KisLayer") || node->inherits("KisColorizeMask")) {
         QString compositeOpName = element.attribute(COMPOSITE_OP, "normal");
         node->setCompositeOpId(compositeOpName);
     }
 
     if (node->inherits("KisLayer")) {
         KisLayer* layer           = qobject_cast<KisLayer*>(node.data());
         QBitArray channelFlags    = stringToFlags(element.attribute(CHANNEL_FLAGS, ""), colorSpace->channelCount());
         layer->setChannelFlags(channelFlags);
 
         if (element.hasAttribute(LAYER_STYLE_UUID)) {
             QString uuidString = element.attribute(LAYER_STYLE_UUID);
             QUuid uuid(uuidString);
             if (!uuid.isNull()) {
                 KisPSDLayerStyleSP dumbLayerStyle(new KisPSDLayerStyle());
                 dumbLayerStyle->setUuid(uuid);
                 layer->setLayerStyle(dumbLayerStyle);
             } else {
                 warnKrita << "WARNING: Layer style for layer" << layer->name() << "contains invalid UUID" << uuidString;
             }
         }
     }
 
     if (node->inherits("KisGroupLayer")) {
         if (element.hasAttribute(PASS_THROUGH_MODE)) {
             bool value = element.attribute(PASS_THROUGH_MODE, "0") != "0";
 
             KisGroupLayer *group = qobject_cast<KisGroupLayer*>(node.data());
             group->setPassThroughMode(value);
         }
     }
 
     if (node->inherits("KisPaintLayer")) {
         KisPaintLayer* layer            = qobject_cast<KisPaintLayer*>(node.data());
         QBitArray      channelLockFlags = stringToFlags(element.attribute(CHANNEL_LOCK_FLAGS, ""), colorSpace->channelCount());
         layer->setChannelLockFlags(channelLockFlags);
 
         bool onionEnabled = element.attribute(ONION_SKIN_ENABLED, "0") == "0" ? false : true;
         layer->setOnionSkinEnabled(onionEnabled);
 
         bool timelineEnabled = element.attribute(VISIBLE_IN_TIMELINE, "0") == "0" ? false : true;
         layer->setUseInTimeline(timelineEnabled);
     }
 
     if (element.attribute(FILE_NAME).isNull()) {
         m_d->layerFilenames[node.data()] = name;
     }
     else {
         m_d->layerFilenames[node.data()] = element.attribute(FILE_NAME);
     }
 
     if (element.hasAttribute("selected") && element.attribute("selected") == "true")  {
         m_d->selectedNodes.append(node);
     }
 
     if (element.hasAttribute(KEYFRAME_FILE)) {
         m_d->keyframeFilenames.insert(node.data(), element.attribute(KEYFRAME_FILE));
     }
 
     return node;
 }
 
 
 KisNodeSP KisKraLoader::loadPaintLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     KisPaintLayer* layer;
 
     layer = new KisPaintLayer(image, name, opacity, cs);
     Q_CHECK_PTR(layer);
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadFileLayer(const KoXmlElement& element, KisImageSP image, const QString& name, quint32 opacity)
 {
     QString filename = element.attribute("source", QString());
     if (filename.isNull()) return 0;
     bool scale = (element.attribute("scale", "true")  == "true");
     int scalingMethod = element.attribute("scalingmethod", "-1").toInt();
     if (scalingMethod < 0) {
         if (scale) {
             scalingMethod = KisFileLayer::ToImagePPI;
         }
         else {
             scalingMethod = KisFileLayer::None;
         }
     }
 
     QString documentPath;
     if (m_d->document) {
         documentPath = m_d->document->url().toLocalFile();
     }
     QFileInfo info(documentPath);
     QString basePath = info.absolutePath();
 
     QString fullPath = basePath + QDir::separator() + filename;
     // Entering the event loop to show the messagebox will delete the image, so up the ref by one
     image->ref();
     if (!QFileInfo(fullPath).exists()) {
 
         qApp->setOverrideCursor(Qt::ArrowCursor);
         QString msg = i18nc(
             "@info",
             "The file associated to a file layer with the name \"%1\" is not found.\n\n"
             "Expected path:\n"
             "%2\n\n"
             "Do you want to locate it manually?", name, fullPath);
 
         int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
         if (result == QMessageBox::Yes) {
 
             KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
             dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
             dialog.setDefaultDir(basePath);
             QString url = dialog.filename();
 
             if (!QFileInfo(basePath).exists()) {
                 filename = url;
             } else {
                 QDir d(basePath);
                 filename = d.relativeFilePath(url);
             }
         }
 
         qApp->restoreOverrideCursor();
     }
 
     KisLayer *layer = new KisFileLayer(image, basePath, filename, (KisFileLayer::ScalingMethod)scalingMethod, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 }
 
 KisNodeSP KisKraLoader::loadGroupLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     Q_UNUSED(cs);
     QString attr;
     KisGroupLayer* layer;
 
     layer = new KisGroupLayer(image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadAdjustmentLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     // XXX: do something with filterversion?
     Q_UNUSED(cs);
     QString attr;
     KisAdjustmentLayer* layer;
     QString filtername;
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid adjustmentlayer! We should warn about it!
         warnFile << "No filter in adjustment layer";
         return 0;
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     layer = new KisAdjustmentLayer(image, name, kfc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadShapeLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
 
     Q_UNUSED(element);
     Q_UNUSED(cs);
 
     QString attr;
     KoShapeBasedDocumentBase * shapeController = 0;
     if (m_d->document) {
         shapeController = m_d->document->shapeController();
     }
     KisShapeLayer* layer = new KisShapeLayer(shapeController, image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadGeneratorLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
     // XXX: do something with generator version?
     KisGeneratorLayer* layer;
     QString generatorname = element.attribute(GENERATOR_NAME);
 
     if (generatorname.isNull()) {
         // XXX: Invalid generator layer! We should warn about it!
         warnFile << "No generator in generator layer";
         return 0;
     }
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->value(generatorname);
     if (!generator) {
         warnFile << "No generator for generatorname" << generatorname << "";
         return 0; // XXX: We don't have this generator. We should warn about it!
     }
 
     KisFilterConfigurationSP  kgc = generator->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     layer = new KisGeneratorLayer(image, name, kgc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadCloneLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
 
     KisCloneLayerSP layer = new KisCloneLayer(0, image, name, opacity);
 
     KisCloneInfo info;
     if (! (element.attribute(CLONE_FROM_UUID)).isNull()) {
         info = KisCloneInfo(QUuid(element.attribute(CLONE_FROM_UUID)));
     } else {
         if ((element.attribute(CLONE_FROM)).isNull()) {
             return 0;
         } else {
             info = KisCloneInfo(element.attribute(CLONE_FROM));
         }
     }
     layer->setCopyFromInfo(info);
 
     if ((element.attribute(CLONE_TYPE)).isNull()) {
         return 0;
     } else {
         layer->setCopyType((CopyLayerType) element.attribute(CLONE_TYPE).toInt());
     }
 
     return layer;
 }
 
 
 KisNodeSP KisKraLoader::loadFilterMask(const KoXmlElement& element, KisNodeSP parent)
 {
     Q_UNUSED(parent);
     QString attr;
     KisFilterMask* mask;
     QString filtername;
 
     // XXX: should we check the version?
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid filter layer! We should warn about it!
         warnFile << "No filter in filter layer";
         return 0;
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     mask = new KisFilterMask();
     mask->setFilter(kfc);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransformMask(const KoXmlElement& element, KisNodeSP parent)
 {
     Q_UNUSED(element);
     Q_UNUSED(parent);
 
     KisTransformMask* mask;
 
     /**
      * We'll load the transform configuration later on a stage
      * of binary data loading
      */
     mask = new KisTransformMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransparencyMask(const KoXmlElement& element, KisNodeSP parent)
 {
     Q_UNUSED(element);
     Q_UNUSED(parent);
     KisTransparencyMask* mask = new KisTransparencyMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadSelectionMask(KisImageSP image, const KoXmlElement& element, KisNodeSP parent)
 {
     Q_UNUSED(parent);
     KisSelectionMaskSP mask = new KisSelectionMask(image);
     bool active = element.attribute(ACTIVE, "1") == "0" ? false : true;
     mask->setActive(active);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadColorizeMask(KisImageSP image, const KoXmlElement& element, KisNodeSP parent, const KoColorSpace *colorSpace)
 {
     Q_UNUSED(parent);
     KisColorizeMaskSP mask = new KisColorizeMask();
     bool editKeystrokes = element.attribute(COLORIZE_EDIT_KEYSTROKES, "1") == "0" ? false : true;
     bool showColoring = element.attribute(COLORIZE_SHOW_COLORING, "1") == "0" ? false : true;
 
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, editKeystrokes, image);
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeShowColoring, showColoring, image);
     delete mask->setColorSpace(colorSpace);
     mask->setImage(image);
 
     return mask;
 }
 
 void KisKraLoader::loadCompositions(const KoXmlElement& elem, KisImageSP image)
 {
     KoXmlNode child;
 
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
 
         KoXmlElement e = child.toElement();
         QString name = e.attribute("name");
         bool exportEnabled = e.attribute("exportEnabled", "1") == "0" ? false : true;
 
         KisLayerCompositionSP composition(new KisLayerComposition(image, name));
         composition->setExportEnabled(exportEnabled);
 
         KoXmlNode value;
         for (value = child.lastChild(); !value.isNull(); value = value.previousSibling()) {
             KoXmlElement e = value.toElement();
             QUuid uuid(e.attribute("uuid"));
             bool visible = e.attribute("visible", "1") == "0" ? false : true;
             composition->setVisible(uuid, visible);
             bool collapsed = e.attribute("collapsed", "1") == "0" ? false : true;
             composition->setCollapsed(uuid, collapsed);
         }
 
         image->addComposition(composition);
     }
 }
 
 void KisKraLoader::loadAssistantsList(const KoXmlElement &elem)
 {
     KoXmlNode child;
     int count = 0;
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
         KoXmlElement e = child.toElement();
         QString type = e.attribute("type");
         QString file_name = e.attribute("filename");
         m_d->assistantsFilenames.insert(file_name,type);
         count++;
 
     }
 }
 
 void KisKraLoader::loadGrid(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGridConfig config;
     config.loadDynamicDataFromXml(domElement);
     config.loadStaticData();
     m_d->document->setGridConfig(config);
 }
 
 void KisKraLoader::loadGuides(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGuidesConfig guides;
     guides.loadFromXml(domElement);
     m_d->document->setGuidesConfig(guides);
 }
 
 void KisKraLoader::loadAudio(const KoXmlElement& elem, KisImageSP image)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement qElement = dom.firstChildElement();
 
     QString fileName;
     if (KisDomUtils::loadValue(qElement, "masterChannelPath", &fileName)) {
         fileName = QDir::toNativeSeparators(fileName);
 
         QDir baseDirectory = QFileInfo(m_d->document->localFilePath()).absoluteDir();
         fileName = baseDirectory.absoluteFilePath(fileName);
 
         QFileInfo info(fileName);
 
         if (!info.exists()) {
             qApp->setOverrideCursor(Qt::ArrowCursor);
             QString msg = i18nc(
                 "@info",
                 "Audio channel file \"%1\" doesn't exist!\n\n"
                 "Expected path:\n"
                 "%2\n\n"
                 "Do you want to locate it manually?", info.fileName(), info.absoluteFilePath());
 
             int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
             if (result == QMessageBox::Yes) {
                 info.setFile(KisImportExportManager::askForAudioFileName(info.absolutePath(), 0));
             }
 
             qApp->restoreOverrideCursor();
         }
 
         if (info.exists()) {
             image->animationInterface()->setAudioChannelFileName(info.absoluteFilePath());
         }
     }
 
     bool audioMuted = false;
     if (KisDomUtils::loadValue(qElement, "audioMuted", &audioMuted)) {
         image->animationInterface()->setAudioMuted(audioMuted);
     }
 
     qreal audioVolume = 0.5;
     if (KisDomUtils::loadValue(qElement, "audioVolume", &audioVolume)) {
         image->animationInterface()->setAudioVolume(audioVolume);
     }
 }
diff --git a/plugins/impex/tiff/kis_tiff_converter.cc b/plugins/impex/tiff/kis_tiff_converter.cc
index bc91421bbb..9899c1e938 100644
--- a/plugins/impex/tiff/kis_tiff_converter.cc
+++ b/plugins/impex/tiff/kis_tiff_converter.cc
@@ -1,743 +1,745 @@
 /*
  *  Copyright (c) 2005-2006 Cyrille Berger <cberger@cberger.net>
  *
  *  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_tiff_converter.h"
 
 #include <stdio.h>
 
 #include <QFile>
 #include <QApplication>
 
 #include <QFileInfo>
 
 #include <KoDocumentInfo.h>
 #include <KoUnit.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 #include <KoColorModelStandardIds.h>
 
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <KoColorProfile.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_transaction.h>
 
 #include "kis_tiff_reader.h"
 #include "kis_tiff_ycbcr_reader.h"
 #include "kis_buffer_stream.h"
 #include "kis_tiff_writer_visitor.h"
 
 #if TIFFLIB_VERSION < 20111221
 typedef size_t tmsize_t;
 #endif
 
 namespace
 {
 
 QPair<QString, QString> getColorSpaceForColorType(uint16 sampletype, uint16 color_type, uint16 color_nb_bits, TIFF *image, uint16 &nbchannels, uint16 &extrasamplescount, uint8 &destDepth)
 {
     if (color_type == PHOTOMETRIC_MINISWHITE || color_type == PHOTOMETRIC_MINISBLACK) {
         if (nbchannels == 0) nbchannels = 1;
         extrasamplescount = nbchannels - 1; // FIX the extrasamples count in case of
         if (sampletype == SAMPLEFORMAT_IEEEFP) {
            if (color_nb_bits == 16) {
                destDepth = 16;
                return QPair<QString, QString>(GrayAColorModelID.id(), Float16BitsColorDepthID.id());
            }
            else if (color_nb_bits == 32) {
                destDepth = 32;
                return QPair<QString, QString>(GrayAColorModelID.id(), Float32BitsColorDepthID.id());
            }
         }
         if (color_nb_bits <= 8) {
             destDepth = 8;
             return QPair<QString, QString>(GrayAColorModelID.id(), Integer8BitsColorDepthID.id());
         }
         else {
             destDepth = 16;
             return QPair<QString, QString>(GrayAColorModelID.id(), Integer16BitsColorDepthID.id());
         }
 
     } else if (color_type == PHOTOMETRIC_RGB  /*|| color_type == */) {
         if (nbchannels == 0) nbchannels = 3;
         extrasamplescount = nbchannels - 3; // FIX the extrasamples count in case of
         if (sampletype == SAMPLEFORMAT_IEEEFP) {
             if (color_nb_bits == 16) {
                 destDepth = 16;
                 return QPair<QString, QString>(RGBAColorModelID.id(), Float16BitsColorDepthID.id());
             }
             else if (color_nb_bits == 32) {
                 destDepth = 32;
                 return QPair<QString, QString>(RGBAColorModelID.id(), Float32BitsColorDepthID.id());
             }
             return QPair<QString, QString>();
         }
         else {
             if (color_nb_bits <= 8) {
                 destDepth = 8;
                 return QPair<QString, QString>(RGBAColorModelID.id(), Integer8BitsColorDepthID.id());
             }
             else {
                 destDepth = 16;
                 return QPair<QString, QString>(RGBAColorModelID.id(), Integer16BitsColorDepthID.id());
             }
         }
     } else if (color_type == PHOTOMETRIC_YCBCR) {
         if (nbchannels == 0) nbchannels = 3;
         extrasamplescount = nbchannels - 3; // FIX the extrasamples count in case of
         if (color_nb_bits <= 8) {
             destDepth = 8;
             return QPair<QString, QString>(YCbCrAColorModelID.id(), Integer8BitsColorDepthID.id());
         }
         else {
             destDepth = 16;
             return QPair<QString, QString>(YCbCrAColorModelID.id(), Integer16BitsColorDepthID.id());
         }
     }
     else if (color_type == PHOTOMETRIC_SEPARATED) {
         if (nbchannels == 0) nbchannels = 4;
         // SEPARATED is in general CMYK but not always, so we check
         uint16 inkset;
         if ((TIFFGetField(image, TIFFTAG_INKSET, &inkset) == 0)) {
             dbgFile << "Image does not define the inkset.";
             inkset = 2;
         }
         if (inkset !=  INKSET_CMYK) {
             dbgFile << "Unsupported inkset (right now, only CMYK is supported)";
             char** ink_names;
             uint16 numberofinks;
             if (TIFFGetField(image, TIFFTAG_INKNAMES, &ink_names)  == 1 && TIFFGetField(image, TIFFTAG_NUMBEROFINKS, &numberofinks)  == 1) {
                 dbgFile << "Inks are :";
                 for (uint i = 0; i < numberofinks; i++) {
                     dbgFile << ink_names[i];
                 }
             }
             else {
                 dbgFile << "inknames are not defined !";
                 // To be able to read stupid adobe files, if there are no information about inks and four channels, then it's a CMYK file :
                 if (nbchannels - extrasamplescount != 4) {
                     return QPair<QString, QString>();
                 }
             }
         }
         if (color_nb_bits <= 8) {
             destDepth = 8;
             return QPair<QString, QString>(CMYKAColorModelID.id(), Integer8BitsColorDepthID.id());
         }
         else {
             destDepth = 16;
             return QPair<QString, QString>(CMYKAColorModelID.id(), Integer16BitsColorDepthID.id());
         }
     }
     else if (color_type == PHOTOMETRIC_CIELAB || color_type == PHOTOMETRIC_ICCLAB) {
         destDepth = 16;
         if (nbchannels == 0) nbchannels = 3;
         extrasamplescount = nbchannels - 3; // FIX the extrasamples count
         return QPair<QString, QString>(LABAColorModelID.id(), Integer16BitsColorDepthID.id());
     }
     else if (color_type ==  PHOTOMETRIC_PALETTE) {
         destDepth = 16;
         if (nbchannels == 0) nbchannels = 2;
         extrasamplescount = nbchannels - 2; // FIX the extrasamples count
         // <-- we will convert the index image to RGBA16 as the palette is always on 16bits colors
         return QPair<QString, QString>(RGBAColorModelID.id(), Integer16BitsColorDepthID.id());
     }
     return QPair<QString, QString>();
 }
 }
 
 KisPropertiesConfigurationSP KisTIFFOptions::toProperties() const
 {
     QHash<int, int> compToIndex;
     compToIndex[COMPRESSION_NONE] = 0;
     compToIndex[COMPRESSION_JPEG] = 1;
     compToIndex[COMPRESSION_DEFLATE] = 2;
     compToIndex[COMPRESSION_LZW] = 3;
     compToIndex[COMPRESSION_JP2000] = 4;
     compToIndex[COMPRESSION_CCITTRLE] = 5;
     compToIndex[COMPRESSION_CCITTFAX3] = 6;
     compToIndex[COMPRESSION_CCITTFAX4] = 7;
     compToIndex[COMPRESSION_PIXARLOG] = 8;
 
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
 
     cfg->setProperty("compressiontype", compToIndex.value(compressionType, 0));
     cfg->setProperty("predictor", predictor - 1);
     cfg->setProperty("alpha", alpha);
     cfg->setProperty("flatten", flatten);
     cfg->setProperty("quality", jpegQuality);
     cfg->setProperty("deflate", deflateCompress);
     cfg->setProperty("faxmode", faxMode - 1);
     cfg->setProperty("pixarlog", pixarLogCompress);
     cfg->setProperty("saveProfile", saveProfile);
 
     return cfg;
 }
 
 void KisTIFFOptions::fromProperties(KisPropertiesConfigurationSP cfg)
 {
     QHash<int, int> indexToComp;
     indexToComp[0] = COMPRESSION_NONE;
     indexToComp[1] = COMPRESSION_JPEG;
     indexToComp[2] = COMPRESSION_DEFLATE;
     indexToComp[3] = COMPRESSION_LZW;
     indexToComp[4] = COMPRESSION_JP2000;
     indexToComp[5] = COMPRESSION_CCITTRLE;
     indexToComp[6] = COMPRESSION_CCITTFAX3;
     indexToComp[7] = COMPRESSION_CCITTFAX4;
     indexToComp[8] = COMPRESSION_PIXARLOG;
 
     compressionType =
         indexToComp.value(
             cfg->getInt("compressiontype", 0),
             COMPRESSION_NONE);
 
     predictor = cfg->getInt("predictor", 0) + 1;
     alpha = cfg->getBool("alpha", true);
     flatten = cfg->getBool("flatten", true);
     jpegQuality = cfg->getInt("quality", 80);
     deflateCompress = cfg->getInt("deflate", 6);
     faxMode = cfg->getInt("faxmode", 0) + 1;
     pixarLogCompress = cfg->getInt("pixarlog", 6);
     saveProfile = cfg->getBool("saveProfile", true);
 }
 
 
 KisTIFFConverter::KisTIFFConverter(KisDocument *doc)
 {
     m_doc = doc;
     m_stop = false;
 
     TIFFSetWarningHandler(0);
     TIFFSetErrorHandler(0);
 }
 
 KisTIFFConverter::~KisTIFFConverter()
 {
 }
 
 KisImageBuilder_Result KisTIFFConverter::decode(const QString &filename)
 {
     dbgFile << "Start decoding TIFF File";
     // Opent the TIFF file
     TIFF *image = 0;
     if ((image = TIFFOpen(QFile::encodeName(filename), "r")) == 0) {
         dbgFile << "Could not open the file, either it does not exist, either it is not a TIFF :" << filename;
         return (KisImageBuilder_RESULT_BAD_FETCH);
     }
     do {
         dbgFile << "Read new sub-image";
         KisImageBuilder_Result result = readTIFFDirectory(image);
         if (result != KisImageBuilder_RESULT_OK) {
             return result;
         }
     } while (TIFFReadDirectory(image));
     // Freeing memory
     TIFFClose(image);
     return KisImageBuilder_RESULT_OK;
 }
 
 KisImageBuilder_Result KisTIFFConverter::readTIFFDirectory(TIFF* image)
 {
     // Read information about the tiff
     uint32 width, height;
     if (TIFFGetField(image, TIFFTAG_IMAGEWIDTH, &width) == 0) {
         dbgFile << "Image does not define its width";
         TIFFClose(image);
         return KisImageBuilder_RESULT_INVALID_ARG;
     }
 
     if (TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height) == 0) {
         dbgFile << "Image does not define its height";
         TIFFClose(image);
         return KisImageBuilder_RESULT_INVALID_ARG;
     }
 
     float xres;
     if (TIFFGetField(image, TIFFTAG_XRESOLUTION, &xres) == 0) {
         dbgFile << "Image does not define x resolution";
         // but we don't stop
         xres = 100;
     }
 
     float yres;
     if (TIFFGetField(image, TIFFTAG_YRESOLUTION, &yres) == 0) {
         dbgFile << "Image does not define y resolution";
         // but we don't stop
         yres = 100;
     }
 
     uint16 depth;
     if ((TIFFGetField(image, TIFFTAG_BITSPERSAMPLE, &depth) == 0)) {
         dbgFile << "Image does not define its depth";
         depth = 1;
     }
 
     uint16 sampletype;
     if ((TIFFGetField(image, TIFFTAG_SAMPLEFORMAT, &sampletype) == 0)) {
         dbgFile << "Image does not define its sample type";
         sampletype =  SAMPLEFORMAT_UINT;
     }
 
     // Determine the number of channels (useful to know if a file has an alpha or not
     uint16 nbchannels;
     if (TIFFGetField(image, TIFFTAG_SAMPLESPERPIXEL, &nbchannels) == 0) {
         dbgFile << "Image has an undefined number of samples per pixel";
         nbchannels = 0;
     }
 
     // Get the number of extrasamples and information about them
     uint16 *sampleinfo = 0, extrasamplescount;
     if (TIFFGetField(image, TIFFTAG_EXTRASAMPLES, &extrasamplescount, &sampleinfo) == 0) {
         extrasamplescount = 0;
     }
 
     // Determine the colorspace
     uint16 color_type;
     if (TIFFGetField(image, TIFFTAG_PHOTOMETRIC, &color_type) == 0) {
         dbgFile << "Image has an undefined photometric interpretation";
         color_type = PHOTOMETRIC_MINISWHITE;
     }
 
     uint8 dstDepth = 0;
-    QPair<QString, QString> colorSpaceId = getColorSpaceForColorType(sampletype, color_type, depth, image, nbchannels, extrasamplescount, dstDepth);
-    if (colorSpaceId.first.isEmpty()) {
+    QPair<QString, QString> colorSpaceIdTag = getColorSpaceForColorType(sampletype, color_type, depth, image, nbchannels, extrasamplescount, dstDepth);
+    if (colorSpaceIdTag.first.isEmpty()) {
         dbgFile << "Image has an unsupported colorspace :" << color_type << " for this depth :" << depth;
         TIFFClose(image);
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
-    dbgFile << "Colorspace is :" << colorSpaceId.first << colorSpaceId.second << " with a depth of" << depth << " and with a nb of channels of" << nbchannels;
+    dbgFile << "Colorspace is :" << colorSpaceIdTag.first << colorSpaceIdTag.second << " with a depth of" << depth << " and with a nb of channels of" << nbchannels;
 
     // Read image profile
     dbgFile << "Reading profile";
     const KoColorProfile* profile = 0;
     quint32 EmbedLen;
     quint8* EmbedBuffer;
 
     if (TIFFGetField(image, TIFFTAG_ICCPROFILE, &EmbedLen, &EmbedBuffer) == 1) {
         dbgFile << "Profile found";
         QByteArray rawdata;
         rawdata.resize(EmbedLen);
         memcpy(rawdata.data(), EmbedBuffer, EmbedLen);
-        profile = KoColorSpaceRegistry::instance()->createColorProfile(colorSpaceId.first, colorSpaceId.second, rawdata);
+        profile = KoColorSpaceRegistry::instance()->createColorProfile(colorSpaceIdTag.first, colorSpaceIdTag.second, rawdata);
     }
 
-    // Check that the profile is used by the color space
+    const QString colorSpaceId =
+        KoColorSpaceRegistry::instance()->colorSpaceId(colorSpaceIdTag.first, colorSpaceIdTag.second);
 
-    if (profile && !KoColorSpaceRegistry::instance()->colorSpaceFactory(KoColorSpaceRegistry::instance()->colorSpaceId(colorSpaceId.first, colorSpaceId.second))->profileIsCompatible(profile)) {
-        dbgFile << "The profile " << profile->name() << " is not compatible with the color space model " << colorSpaceId.first << " " << colorSpaceId.second;
+    // Check that the profile is used by the color space
+    if (profile && !KoColorSpaceRegistry::instance()->profileIsCompatible(profile, colorSpaceId)) {
+        dbgFile << "The profile " << profile->name() << " is not compatible with the color space model " << colorSpaceIdTag.first << " " << colorSpaceIdTag.second;
         profile = 0;
     }
 
     // Do not use the linear gamma profile for 16 bits/channel by default, tiff files are usually created with
     // gamma correction. XXX: Should we ask the user?
-    if (!profile && colorSpaceId.first == RGBAColorModelID.id() && colorSpaceId.second == Integer16BitsColorDepthID.id()) {
+    if (!profile && colorSpaceIdTag.first == RGBAColorModelID.id() && colorSpaceIdTag.second == Integer16BitsColorDepthID.id()) {
         profile = KoColorSpaceRegistry::instance()->profileByName("sRGB-elle-V2-srgbtrc.icc");
         dbgFile << "Getting srgb profile" << profile;
      }
 
     // Retrieve a pointer to the colorspace
     const KoColorSpace* cs = 0;
     if (profile && profile->isSuitableForOutput()) {
         dbgFile << "image has embedded profile:" << profile -> name() << "";
-        cs = KoColorSpaceRegistry::instance()->colorSpace(colorSpaceId.first, colorSpaceId.second, profile);
+        cs = KoColorSpaceRegistry::instance()->colorSpace(colorSpaceIdTag.first, colorSpaceIdTag.second, profile);
     }
     else {
-        cs = KoColorSpaceRegistry::instance()->colorSpace(colorSpaceId.first, colorSpaceId.second, 0);
+        cs = KoColorSpaceRegistry::instance()->colorSpace(colorSpaceIdTag.first, colorSpaceIdTag.second, 0);
     }
 
     if (cs == 0) {
-        dbgFile << "Colorspace" << colorSpaceId.first << colorSpaceId.second << " is not available, please check your installation.";
+        dbgFile << "Colorspace" << colorSpaceIdTag.first << colorSpaceIdTag.second << " is not available, please check your installation.";
         TIFFClose(image);
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
 
     // Create the cmsTransform if needed
     KoColorTransformation* transform = 0;
     if (profile && !profile->isSuitableForOutput()) {
         dbgFile << "The profile can't be used in krita, need conversion";
-        transform = KoColorSpaceRegistry::instance()->colorSpace(colorSpaceId.first, colorSpaceId.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
+        transform = KoColorSpaceRegistry::instance()->colorSpace(colorSpaceIdTag.first, colorSpaceIdTag.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     }
 
     // Check if there is an alpha channel
     int8 alphapos = -1; // <- no alpha
     // Check which extra is alpha if any
     dbgFile << "There are" << nbchannels << " channels and" << extrasamplescount << " extra channels";
     if (sampleinfo) { // index images don't have any sampleinfo, and therefor sampleinfo == 0
         for (int i = 0; i < extrasamplescount; i ++) {
             dbgFile << i << "" << extrasamplescount << ""  << (cs->colorChannelCount()) <<  nbchannels << "" << sampleinfo[i];
             if (sampleinfo[i] == EXTRASAMPLE_ASSOCALPHA) {
                 // XXX: dangelo: the color values are already multiplied with
                 // the alpha value.  This needs to be reversed later (postprocessor?)
                 alphapos = i;
             }
 
             if (sampleinfo[i] == EXTRASAMPLE_UNASSALPHA) {
                 // color values are not premultiplied with alpha, and can be used as they are.
                 alphapos = i;
             }
         }
     }
 
     dbgFile << "Alpha pos:" << alphapos;
 
     // Read META Information
     KoDocumentInfo * info = m_doc->documentInfo();
     char* text;
     if (TIFFGetField(image, TIFFTAG_ARTIST, &text) == 1) {
         info->setAuthorInfo("creator", text);
     }
     if (TIFFGetField(image, TIFFTAG_DOCUMENTNAME, &text) == 1) {
         info->setAboutInfo("title", text);
     }
     if (TIFFGetField(image, TIFFTAG_IMAGEDESCRIPTION, &text)  == 1) {
         info->setAboutInfo("description", text);
     }
 
 
     // Get the planar configuration
     uint16 planarconfig;
     if (TIFFGetField(image, TIFFTAG_PLANARCONFIG, &planarconfig) == 0) {
         dbgFile << "Plannar configuration is not define";
         TIFFClose(image);
         return KisImageBuilder_RESULT_INVALID_ARG;
     }
     // Creating the KisImageSP
     if (! m_image) {
         m_image = new KisImage(m_doc->createUndoStore(), width, height, cs, "built image");
         m_image->setResolution( POINT_TO_INCH(xres), POINT_TO_INCH(yres )); // It is the "invert" macro because we convert from pointer-per-inchs to points
         Q_CHECK_PTR(m_image);
     }
     else {
         if (m_image->width() < (qint32)width || m_image->height() < (qint32)height) {
             quint32 newwidth = (m_image->width() < (qint32)width) ? width : m_image->width();
             quint32 newheight = (m_image->height() < (qint32)height) ? height : m_image->height();
             m_image->resizeImage(QRect(0,0,newwidth, newheight));
         }
     }
     KisPaintLayer* layer = new KisPaintLayer(m_image.data(), m_image -> nextLayerName(), quint8_MAX);
     tdata_t buf = 0;
     tdata_t* ps_buf = 0; // used only for planar configuration separated
     KisBufferStreamBase* tiffstream;
 
     KisTIFFReaderBase* tiffReader = 0;
 
     quint8 poses[5];
     KisTIFFPostProcessor* postprocessor = 0;
 
     // Configure poses
     uint8 nbcolorsamples = nbchannels - extrasamplescount;
     switch (color_type) {
     case PHOTOMETRIC_MINISWHITE: {
         poses[0] = 0; poses[1] = 1;
         postprocessor = new KisTIFFPostProcessorInvert(nbcolorsamples);
     }
         break;
     case PHOTOMETRIC_MINISBLACK: {
         poses[0] = 0; poses[1] = 1;
         postprocessor = new KisTIFFPostProcessor(nbcolorsamples);
     }
         break;
     case PHOTOMETRIC_CIELAB: {
         poses[0] = 0; poses[1] = 1; poses[2] = 2; poses[3] = 3;
         postprocessor = new KisTIFFPostProcessorCIELABtoICCLAB(nbcolorsamples);
     }
         break;
     case PHOTOMETRIC_ICCLAB: {
         poses[0] = 0; poses[1] = 1; poses[2] = 2; poses[3] = 3;
         postprocessor = new KisTIFFPostProcessor(nbcolorsamples);
     }
         break;
     case PHOTOMETRIC_RGB: {
         if (sampletype == SAMPLEFORMAT_IEEEFP)
         {
             poses[2] = 2; poses[1] = 1; poses[0] = 0; poses[3] = 3;
         } else {
             poses[0] = 2; poses[1] = 1; poses[2] = 0; poses[3] = 3;
         }
         postprocessor = new KisTIFFPostProcessor(nbcolorsamples);
     }
         break;
     case PHOTOMETRIC_SEPARATED: {
         poses[0] = 0; poses[1] = 1; poses[2] = 2; poses[3] = 3; poses[4] = 4;
         postprocessor = new KisTIFFPostProcessor(nbcolorsamples);
     }
         break;
     default:
         break;
     }
 
 
     // Initisalize tiffReader
     uint16 * lineSizeCoeffs = new uint16[nbchannels];
     uint16 vsubsampling = 1;
     uint16 hsubsampling = 1;
     for (uint i = 0; i < nbchannels; i++) {
         lineSizeCoeffs[i] = 1;
     }
     if (color_type == PHOTOMETRIC_PALETTE) {
         uint16 *red; // No need to free them they are free by libtiff
         uint16 *green;
         uint16 *blue;
         if ((TIFFGetField(image, TIFFTAG_COLORMAP, &red, &green, &blue)) == 0) {
             dbgFile << "Indexed image does not define a palette";
             TIFFClose(image);
             delete [] lineSizeCoeffs;
             return KisImageBuilder_RESULT_INVALID_ARG;
         }
 
         tiffReader = new KisTIFFReaderFromPalette(layer->paintDevice(), red, green, blue, poses, alphapos, depth, sampletype, nbcolorsamples, extrasamplescount, transform, postprocessor);
     } else if (color_type == PHOTOMETRIC_YCBCR) {
         TIFFGetFieldDefaulted(image, TIFFTAG_YCBCRSUBSAMPLING, &hsubsampling, &vsubsampling);
         lineSizeCoeffs[1] = hsubsampling;
         lineSizeCoeffs[2] = hsubsampling;
         uint16 position;
         TIFFGetFieldDefaulted(image, TIFFTAG_YCBCRPOSITIONING, &position);
         if (dstDepth == 8) {
             tiffReader = new KisTIFFYCbCrReaderTarget8Bit(layer->paintDevice(), layer->image()->width(), layer->image()->height(), poses, alphapos, depth, sampletype, nbcolorsamples, extrasamplescount, transform, postprocessor, hsubsampling, vsubsampling, (KisTIFFYCbCr::Position)position);
         }
         else if (dstDepth == 16) {
             tiffReader = new KisTIFFYCbCrReaderTarget16Bit(layer->paintDevice(), layer->image()->width(), layer->image()->height(), poses, alphapos, depth, sampletype, nbcolorsamples, extrasamplescount, transform, postprocessor, hsubsampling, vsubsampling, (KisTIFFYCbCr::Position)position);
         }
     }
     else if (dstDepth == 8) {
         tiffReader = new KisTIFFReaderTarget8bit(layer->paintDevice(), poses, alphapos, depth, sampletype, nbcolorsamples, extrasamplescount, transform, postprocessor);
     }
     else if (dstDepth == 16) {
         uint16 alphaValue;
         if (sampletype == SAMPLEFORMAT_IEEEFP)
         {
           alphaValue = 15360; // representation of 1.0 in half
         } else {
           alphaValue = quint16_MAX;
         }
         tiffReader = new KisTIFFReaderTarget16bit(layer->paintDevice(), poses, alphapos, depth, sampletype, nbcolorsamples, extrasamplescount, transform, postprocessor, alphaValue);
     }
     else if (dstDepth == 32) {
         union {
           float f;
           uint32 i;
         } alphaValue;
         if (sampletype == SAMPLEFORMAT_IEEEFP)
         {
           alphaValue.f = 1.0f;
         } else {
           alphaValue.i = quint32_MAX;
         }
         tiffReader = new KisTIFFReaderTarget32bit(layer->paintDevice(), poses, alphapos, depth, sampletype, nbcolorsamples, extrasamplescount, transform, postprocessor, alphaValue.i);
     }
 
     if (!tiffReader) {
         delete postprocessor;
         delete[] lineSizeCoeffs;
         TIFFClose(image);
         dbgFile << "Image has an invalid/unsupported color type: " << color_type;
         return KisImageBuilder_RESULT_INVALID_ARG;
     }
 
     if (TIFFIsTiled(image)) {
         dbgFile << "tiled image";
         uint32 tileWidth, tileHeight;
         uint32 x, y;
         TIFFGetField(image, TIFFTAG_TILEWIDTH, &tileWidth);
         TIFFGetField(image, TIFFTAG_TILELENGTH, &tileHeight);
         uint32 linewidth = (tileWidth * depth * nbchannels) / 8;
         if (planarconfig == PLANARCONFIG_CONTIG) {
             buf = _TIFFmalloc(TIFFTileSize(image));
             if (depth < 16) {
                 tiffstream = new KisBufferStreamContigBelow16((uint8*)buf, depth, linewidth);
             }
             else if (depth < 32) {
                 tiffstream = new KisBufferStreamContigBelow32((uint8*)buf, depth, linewidth);
             }
             else {
                 tiffstream = new KisBufferStreamContigAbove32((uint8*)buf, depth, linewidth);
             }
         }
         else {
             ps_buf = new tdata_t[nbchannels];
             uint32 * lineSizes = new uint32[nbchannels];
             tmsize_t baseSize = TIFFTileSize(image) / nbchannels;
             for (uint i = 0; i < nbchannels; i++) {
                 ps_buf[i] = _TIFFmalloc(baseSize);
                 lineSizes[i] = tileWidth; // baseSize / lineSizeCoeffs[i];
             }
             tiffstream = new KisBufferStreamSeperate((uint8**) ps_buf, nbchannels, depth, lineSizes);
             delete [] lineSizes;
         }
         dbgFile << linewidth << "" << nbchannels << "" << layer->paintDevice()->colorSpace()->colorChannelCount();
         for (y = 0; y < height; y += tileHeight) {
             for (x = 0; x < width; x += tileWidth) {
                 dbgFile << "Reading tile x =" << x << " y =" << y;
                 if (planarconfig == PLANARCONFIG_CONTIG) {
                     TIFFReadTile(image, buf, x, y, 0, (tsample_t) - 1);
                 }
                 else {
                     for (uint i = 0; i < nbchannels; i++) {
                         TIFFReadTile(image, ps_buf[i], x, y, 0, i);
                     }
                 }
                 uint32 realTileWidth = (x + tileWidth) < width ? tileWidth : width - x;
                 for (uint yintile = 0; y + yintile < height && yintile < tileHeight / vsubsampling;) {
                     tiffReader->copyDataToChannels(x, y + yintile , realTileWidth, tiffstream);
                     yintile += 1;
                     tiffstream->moveToLine(yintile);
                 }
                 tiffstream->restart();
             }
         }
     }
     else {
         dbgFile << "striped image";
         tsize_t stripsize = TIFFStripSize(image);
         uint32 rowsPerStrip;
         TIFFGetFieldDefaulted(image, TIFFTAG_ROWSPERSTRIP, &rowsPerStrip);
         dbgFile << rowsPerStrip << "" << height;
         rowsPerStrip = qMin(rowsPerStrip, height); // when TIFFNumberOfStrips(image) == 1 it might happen that rowsPerStrip is incorrectly set
         if (planarconfig == PLANARCONFIG_CONTIG) {
             buf = _TIFFmalloc(stripsize);
             if (depth < 16) {
                 tiffstream = new KisBufferStreamContigBelow16((uint8*)buf, depth, stripsize / rowsPerStrip);
             }
             else if (depth < 32) {
                 tiffstream = new KisBufferStreamContigBelow32((uint8*)buf, depth, stripsize / rowsPerStrip);
             }
             else {
                 tiffstream = new KisBufferStreamContigAbove32((uint8*)buf, depth, stripsize / rowsPerStrip);
             }
         }
         else {
             ps_buf = new tdata_t[nbchannels];
             uint32 scanLineSize = stripsize / rowsPerStrip;
             dbgFile << " scanLineSize for each plan =" << scanLineSize;
             uint32 * lineSizes = new uint32[nbchannels];
             for (uint i = 0; i < nbchannels; i++) {
                 ps_buf[i] = _TIFFmalloc(stripsize);
                 lineSizes[i] = scanLineSize / lineSizeCoeffs[i];
             }
             tiffstream = new KisBufferStreamSeperate((uint8**) ps_buf, nbchannels, depth, lineSizes);
             delete [] lineSizes;
         }
 
         dbgFile << "Scanline size =" << TIFFRasterScanlineSize(image) << " / strip size =" << TIFFStripSize(image) << " / rowsPerStrip =" << rowsPerStrip << " stripsize/rowsPerStrip =" << stripsize / rowsPerStrip;
         uint32 y = 0;
         dbgFile << " NbOfStrips =" << TIFFNumberOfStrips(image) << " rowsPerStrip =" << rowsPerStrip << " stripsize =" << stripsize;
         for (uint32 strip = 0; y < height; strip++) {
             if (planarconfig == PLANARCONFIG_CONTIG) {
                 TIFFReadEncodedStrip(image, TIFFComputeStrip(image, y, 0) , buf, (tsize_t) - 1);
             }
             else {
                 for (uint i = 0; i < nbchannels; i++) {
                     TIFFReadEncodedStrip(image, TIFFComputeStrip(image, y, i), ps_buf[i], (tsize_t) - 1);
                 }
             }
             for (uint32 yinstrip = 0 ; yinstrip < rowsPerStrip && y < height ;) {
                 uint linesread = tiffReader->copyDataToChannels(0, y, width, tiffstream);
                 y += linesread;
                 yinstrip += linesread;
                 tiffstream->moveToLine(yinstrip);
             }
             tiffstream->restart();
         }
     }
     tiffReader->finalize();
     delete[] lineSizeCoeffs;
     delete tiffReader;
     delete tiffstream;
     if (planarconfig == PLANARCONFIG_CONTIG) {
         _TIFFfree(buf);
     } else {
         for (uint i = 0; i < nbchannels; i++) {
             _TIFFfree(ps_buf[i]);
         }
         delete[] ps_buf;
     }
 
     m_image->addNode(KisNodeSP(layer), m_image->rootLayer().data());
     return KisImageBuilder_RESULT_OK;
 }
 
 KisImageBuilder_Result KisTIFFConverter::buildImage(const QString &filename)
 {
     return decode(filename);
 }
 
 
 KisImageSP KisTIFFConverter::image()
 {
     return m_image;
 }
 
 
 KisImageBuilder_Result KisTIFFConverter::buildFile(const QString &filename, KisImageSP kisimage, KisTIFFOptions options)
 {
     dbgFile << "Start writing TIFF File";
     if (!kisimage)
         return KisImageBuilder_RESULT_EMPTY;
 
     // Open file for writing
     TIFF *image;
     if ((image = TIFFOpen(QFile::encodeName(filename), "w")) == 0) {
         dbgFile << "Could not open the file for writing" << filename;
         TIFFClose(image);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Set the document information
     KoDocumentInfo * info = m_doc->documentInfo();
     QString title = info->aboutInfo("title");
     if (!title.isEmpty()) {
         TIFFSetField(image, TIFFTAG_DOCUMENTNAME, title.toLatin1().constData());
     }
     QString abstract = info->aboutInfo("description");
     if (!abstract.isEmpty()) {
         TIFFSetField(image, TIFFTAG_IMAGEDESCRIPTION, abstract.toLatin1().constData());
     }
     QString author = info->authorInfo("creator");
     if (!author.isEmpty()) {
         TIFFSetField(image, TIFFTAG_ARTIST, author.toLatin1().constData());
     }
 
     dbgFile << "xres: " << INCH_TO_POINT(kisimage->xRes()) << " yres: " << INCH_TO_POINT(kisimage->yRes());
     TIFFSetField(image, TIFFTAG_XRESOLUTION, INCH_TO_POINT(kisimage->xRes())); // It is the "invert" macro because we convert from pointer-per-inchs to points
     TIFFSetField(image, TIFFTAG_YRESOLUTION, INCH_TO_POINT(kisimage->yRes()));
 
     KisGroupLayer* root = dynamic_cast<KisGroupLayer*>(kisimage->rootLayer().data());
     if (root == 0) {
         TIFFClose(image);
         return KisImageBuilder_RESULT_FAILURE;
     }
     KisTIFFWriterVisitor* visitor = new KisTIFFWriterVisitor(image, &options);
     if (!visitor->visit(root)) {
         TIFFClose(image);
         return KisImageBuilder_RESULT_FAILURE;
     }
 
     TIFFClose(image);
     return KisImageBuilder_RESULT_OK;
 }
 
 
 void KisTIFFConverter::cancel()
 {
     m_stop = true;
 }