diff --git a/libs/resources/KisResourceLocator.cpp b/libs/resources/KisResourceLocator.cpp
index 08e729fae5..d60d677523 100644
--- a/libs/resources/KisResourceLocator.cpp
+++ b/libs/resources/KisResourceLocator.cpp
@@ -1,550 +1,550 @@
 /*
  * Copyright (C) 2018 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 "KisResourceLocator.h"
 
 #include <QApplication>
 #include <QDebug>
 #include <QList>
 #include <QDir>
 #include <QDirIterator>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QVersionNumber>
 
 #include <QSqlQuery>
 #include <QSqlError>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 #include <klocalizedstring.h>
 
 #include <KritaVersionWrapper.h>
 #include <KisMimeDatabase.h>
 
 #include "KoResourcePaths.h"
 #include "KisResourceStorage.h"
 #include "KisResourceCacheDb.h"
 #include "KisResourceLoaderRegistry.h"
 #include "KisMemoryStorage.h"
 #include "KisResourceModelProvider.h"
 
 
 const QString KisResourceLocator::resourceLocationKey {"ResourceDirectory"};
 
 
 class KisResourceLocator::Private {
 public:
     QString resourceLocation;
     QMap<QString, KisResourceStorageSP> storages;
     QHash<QPair<QString, QString>, KoResourceSP> resourceCache;
     QStringList errorMessages;
 };
 
 KisResourceLocator::KisResourceLocator(QObject *parent)
     : QObject(parent)
     , d(new Private())
 {
 }
 
 KisResourceLocator *KisResourceLocator::instance()
 {
     // Not a regular Q_GLOBAL_STATIC, because we want this deleted as
     // part of the app destructor.
     KisResourceLocator *locator = qApp->findChild<KisResourceLocator *>(QString());
     if (!locator) {
         locator = new KisResourceLocator(qApp);
     }
     return locator;
 }
 
 KisResourceLocator::~KisResourceLocator()
 {
 }
 
 KisResourceLocator::LocatorError KisResourceLocator::initialize(const QString &installationResourcesLocation)
 {
     InitalizationStatus initalizationStatus = InitalizationStatus::Unknown;
 
     KConfigGroup cfg(KSharedConfig::openConfig(), "");
     d->resourceLocation = cfg.readEntry(resourceLocationKey, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation));
     if (!d->resourceLocation.endsWith('/')) d->resourceLocation += '/';
 
     QFileInfo fi(d->resourceLocation);
 
     if (!fi.exists()) {
         if (!QDir().mkpath(d->resourceLocation)) {
             d->errorMessages << i18n("1. Could not create the resource location at %1.", d->resourceLocation);
             return LocatorError::CannotCreateLocation;
         }
         initalizationStatus = InitalizationStatus::FirstRun;
     }
 
     if (!fi.isWritable()) {
         d->errorMessages << i18n("2. The resource location at %1 is not writable.", d->resourceLocation);
         return LocatorError::LocationReadOnly;
     }
 
     // Check whether we're updating from an older version
     if (initalizationStatus != InitalizationStatus::FirstRun) {
         QFile fi(d->resourceLocation + '/' + "KRITA_RESOURCE_VERSION");
         if (!fi.exists()) {
             initalizationStatus = InitalizationStatus::FirstUpdate;
         }
         else {
             fi.open(QFile::ReadOnly);
             QVersionNumber resource_version = QVersionNumber::fromString(QString::fromUtf8(fi.readAll()));
             QVersionNumber krita_version = QVersionNumber::fromString(KritaVersionWrapper::versionString());
             if (krita_version > resource_version) {
                 initalizationStatus = InitalizationStatus::Updating;
             }
             else {
                 initalizationStatus = InitalizationStatus::Initialized;
             }
         }
     }
 
     if (initalizationStatus != InitalizationStatus::Initialized) {
         KisResourceLocator::LocatorError res = firstTimeInstallation(initalizationStatus, installationResourcesLocation);
         if (res != LocatorError::Ok) {
             return res;
         }
         initalizationStatus = InitalizationStatus::Initialized;
     }
     else {
         if (!synchronizeDb()) {
             return LocatorError::CannotSynchronizeDb;
         }
     }
     return LocatorError::Ok;
 }
 
 QStringList KisResourceLocator::errorMessages() const
 {
     return d->errorMessages;
 }
 
 QString KisResourceLocator::resourceLocationBase() const
 {
     return d->resourceLocation;
 }
 
 bool KisResourceLocator::resourceCached(QString storageLocation, const QString &resourceType, const QString &filename) const
 {
     storageLocation = makeStorageLocationAbsolute(storageLocation);
     QPair<QString, QString> key = QPair<QString, QString> (storageLocation, resourceType + "/" + filename);
 
     return d->resourceCache.contains(key);
 }
 
 KoResourceSP KisResourceLocator::resource(QString storageLocation, const QString &resourceType, const QString &filename)
 {
     storageLocation = makeStorageLocationAbsolute(storageLocation);
 
     QPair<QString, QString> key = QPair<QString, QString> (storageLocation, resourceType + "/" + filename);
 
     KoResourceSP resource;
     if (d->resourceCache.contains(key)) {
         resource = d->resourceCache[key];
     }
     else {
         KisResourceStorageSP storage = d->storages[storageLocation];
         Q_ASSERT(storage);
 
         resource = storage->resource(resourceType + "/" + filename);
         Q_ASSERT(resource);
 
         if (resource) {
             d->resourceCache[key] = resource;
         }
     }
     Q_ASSERT(resource);
     resource->setStorageLocation(storageLocation);
     Q_ASSERT(!resource->storageLocation().isEmpty());
     return resource;
 }
 
 KoResourceSP KisResourceLocator::resourceForId(int resourceId)
 {
     ResourceStorage rs = getResourceStorage(resourceId);
     KoResourceSP r = resource(rs.storageLocation, rs.resourceType, rs.resourceFileName);
     Q_ASSERT(r);
     r->setResourceId(resourceId);
 
     return r;
 }
 
 bool KisResourceLocator::removeResource(int resourceId, const QString &storageLocation)
 {
     // First remove the resource from the cache
     ResourceStorage rs = getResourceStorage(resourceId);
     QPair<QString, QString> key = QPair<QString, QString> (rs.storageLocation, rs.resourceType + "/" + rs.resourceFileName);
 
     d->resourceCache.remove(key);
 
     return KisResourceCacheDb::removeResource(resourceId);
 }
 
 bool KisResourceLocator::importResourceFromFile(const QString &resourceType, const QString &fileName, const QString &storageLocation)
 {
     KisResourceLoaderBase *loader = KisResourceLoaderRegistry::instance()->loader(resourceType, KisMimeDatabase::mimeTypeForFile(fileName));
     QFile f(fileName);
     if (!f.open(QFile::ReadOnly)) {
         qWarning() << "Could not open" << fileName << "for loading";
         return false;
     }
 
     KoResourceSP resource = loader->load(QFileInfo(fileName).fileName(), f);
     if (!resource) {
         qWarning() << "Could not import" << fileName << ": resource doesn't load.";
         return false;
     }
     KisResourceStorageSP storage = d->storages[makeStorageLocationAbsolute(storageLocation)];
     Q_ASSERT(storage);
     if (!storage->addResource(resource)) {
         qWarning() << "Could not add resource" << resource->filename() << "to the folder storage";
         return false;
     }
 
     return KisResourceCacheDb::addResource(folderStorage(), QFileInfo(resource->filename()).lastModified(), resource, resourceType);
 }
 
 bool KisResourceLocator::addResource(const QString &resourceType, const KoResourceSP resource, const QString &storageLocation)
 {
     if (!resource || !resource->valid()) return false;
 
     KisResourceStorageSP storage = d->storages[makeStorageLocationAbsolute(storageLocation)];
     Q_ASSERT(storage);
 
     //If we have gotten this far and the resource still doesn't have a filename to save to, we should generate one.
     if (resource->filename().isEmpty()) {
         if (storageLocation == "memory") {
             resource->setFilename("memory/" + resourceType + "/" + resource->name());
         }
         else {
             resource->setFilename(resource->name().split(" ").join("_") + resource->defaultFileExtension());
         }
     }
 
     // Save the resource to the storage storage
     if (!storage->addResource(resource)) {
         qWarning() << "Could not add resource" << resource->filename() << "to the folder storage";
         return false;
     }
 
     // And the database
     return KisResourceCacheDb::addResource(storage,
                                            QFileInfo(resource->filename()).lastModified(),
                                            resource,
                                            resourceType);
 
 }
 
 bool KisResourceLocator::updateResource(const QString &resourceType, const KoResourceSP resource)
 {
 
     QString storageLocation = makeStorageLocationAbsolute(resource->storageLocation());
 
     Q_ASSERT(d->storages.contains(storageLocation));
     Q_ASSERT(resource->resourceId() > -1);
 
     KisResourceStorageSP storage = d->storages[storageLocation];
 
     int version = resource->version();
 
     if (!storage->addResource(resource)) {
         qWarning() << "Failed to save the new version of " << resource->name() << "to storage" << storageLocation;
         return false;
     }
 
     // It's the storages that keep track of the version
     Q_ASSERT(resource->version() == version + 1);
 
     if (!KisResourceCacheDb::addResourceVersion(resource->resourceId(), QDateTime::currentDateTime(), storage, resource)) {
         qWarning() << "Failed to add a new version of the resource to the database" << resource->name();
         return false;
     }
 
     // Update the resource in the cache
     QPair<QString, QString> key = QPair<QString, QString> (storageLocation, resourceType + "/" + QFileInfo(resource->filename()).fileName());
     d->resourceCache[key] = resource;
 
     return true;
 }
 
 QMap<QString, QVariant> KisResourceLocator::metaDataForResource(int id) const
 {
     return KisResourceCacheDb::metaDataForId(id, "resources");
 }
 
 bool KisResourceLocator::setMetaDataForResource(int id, QMap<QString, QVariant> map) const
 {
     return KisResourceCacheDb::updateMetaDataForId(map, id, "resources");
 }
 
 void KisResourceLocator::purge()
 {
     d->resourceCache.clear();
 }
 
 bool KisResourceLocator::addStorage(const QString &document, KisResourceStorageSP storage)
 {
     Q_ASSERT(!d->storages.contains(document));
 
     d->storages[document] = storage;
 
     if (!KisResourceCacheDb::addStorage(storage, false)) {
         d->errorMessages.append(i18n("Could not add %1 to the database", storage->location()));
         return false;
     }
 
     KisResourceModelProvider::resetAllModels();
     return true;
 }
 
 bool KisResourceLocator::removeStorage(const QString &document)
 {
     // Cloned documents have a document storage, but that isn't in the locator.
     if (!d->storages.contains(document)) return true;
 
     purge();
     KisResourceStorageSP storage = d->storages.take(document);
     if (!KisResourceCacheDb::deleteStorage(storage)) {
         d->errorMessages.append(i18n("Could not remove storage %1 from the database", storage->location()));
         return false;
     }
     KisResourceModelProvider::resetAllModels();
     return true;
 }
 
 bool KisResourceLocator::hasStorage(const QString &document)
 {
     return d->storages.contains(document);
 }
 
 KisResourceLocator::LocatorError KisResourceLocator::firstTimeInstallation(InitalizationStatus initalizationStatus, const QString &installationResourcesLocation)
 {
     emit progressMessage(i18n("Krita is running for the first time. Intialization will take some time."));
     Q_UNUSED(initalizationStatus);
 
     Q_FOREACH(const QString &folder, KisResourceLoaderRegistry::instance()->resourceTypes()) {
         QDir dir(d->resourceLocation + '/' + folder + '/');
         if (!dir.exists()) {
             if (!QDir().mkpath(d->resourceLocation + '/' + folder + '/')) {
                 d->errorMessages << i18n("3. Could not create the resource location at %1.", dir.path());
                 return LocatorError::CannotCreateLocation;
             }
         }
     }
 
     Q_FOREACH(const QString &folder, KisResourceLoaderRegistry::instance()->resourceTypes()) {
         QDir dir(installationResourcesLocation + '/' + folder + '/');
         if (dir.exists()) {
             Q_FOREACH(const QString &entry, dir.entryList(QDir::Files | QDir::Readable)) {
                 QFile f(dir.canonicalPath() + '/'+ entry);
                 if (!QFileInfo(d->resourceLocation + '/' + folder + '/' + entry).exists()) {
                     if (!f.copy(d->resourceLocation + '/' + folder + '/' + entry)) {
                         d->errorMessages << i18n("Could not copy resource %1 to %2", f.fileName(), d->resourceLocation + '/' + folder + '/' + entry);
                     }
                 }
             }
         }
     }
 
     // And add bundles and adobe libraries
     QStringList filters = QStringList() << "*.bundle" << "*.abr" << "*.asl";
     QDirIterator iter(installationResourcesLocation, filters, QDir::Files, QDirIterator::Subdirectories);
     while (iter.hasNext()) {
         iter.next();
         emit progressMessage(i18n("Installing the resources from bundle %1.", iter.filePath()));
         QFile f(iter.filePath());
         Q_ASSERT(f.exists());
         if (!f.copy(d->resourceLocation + '/' + iter.fileName())) {
             d->errorMessages << i18n("Could not copy resource %1 to %2", f.fileName(), d->resourceLocation);
         }
     }
 
     QFile f(d->resourceLocation + '/' + "KRITA_RESOURCE_VERSION");
     f.open(QFile::WriteOnly);
     f.write(KritaVersionWrapper::versionString().toUtf8());
     f.close();
 
     if (!initializeDb()) {
         return LocatorError::CannotInitializeDb;
     }
 
     return LocatorError::Ok;
 }
 
 bool KisResourceLocator::initializeDb()
 {
     emit progressMessage(i18n("Initalizing the resources."));
     d->errorMessages.clear();
     findStorages();
 
     Q_FOREACH(KisResourceStorageSP storage, d->storages) {
 
         QTime t;
         t.start();
 
         if (!KisResourceCacheDb::addStorage(storage, (storage->type() == KisResourceStorage::StorageType::Folder ? false : true))) {
             d->errorMessages.append(i18n("Could not add storage %1 to the cache database", storage->location()));
         }
 
         qDebug() << "Adding storage" << storage->location() << "to the database took" << t.elapsed() << "ms";
     }
 
     return (d->errorMessages.isEmpty());
 }
 
 void KisResourceLocator::findStorages()
 {
     d->storages.clear();
 
     // Add the folder
     KisResourceStorageSP storage = QSharedPointer<KisResourceStorage>::create(d->resourceLocation);
     Q_ASSERT(storage->location() == d->resourceLocation);
     d->storages[d->resourceLocation] = storage;
 
     // Add the memory storage
     d->storages["memory"] = QSharedPointer<KisResourceStorage>::create("memory");
 
     // And add bundles and adobe libraries
     QStringList filters = QStringList() << "*.bundle" << "*.abr" << "*.asl";
     QDirIterator iter(d->resourceLocation, filters, QDir::Files, QDirIterator::Subdirectories);
     while (iter.hasNext()) {
         iter.next();
         KisResourceStorageSP storage = QSharedPointer<KisResourceStorage>::create(iter.filePath());
         d->storages[storage->location()] = storage;
     }
 }
 
 QList<KisResourceStorageSP> KisResourceLocator::storages() const
 {
     return d->storages.values();
 }
 
-KisResourceStorageSP KisResourceLocator::storageByName(const QString &name) const
+KisResourceStorageSP KisResourceLocator::storageByLocation(const QString &location) const
 {
-    if (!d->storages.contains(name)) {
-        qWarning() << "No" << name << "storage defined";
+    if (!d->storages.contains(location)) {
+        qWarning() << "No" << location << "storage defined";
         return 0;
     }
-    KisResourceStorageSP storage = d->storages[name];
+    KisResourceStorageSP storage = d->storages[location];
     if (!storage || !storage->valid()) {
-        qWarning() << "Could not retrieve the" << name << "storage object or the object is not valid";
+        qWarning() << "Could not retrieve the" << location << "storage object or the object is not valid";
         return 0;
     }
 
     return storage;
 }
 
 KisResourceStorageSP KisResourceLocator::folderStorage() const
 {
-    return storageByName(d->resourceLocation);
+    return storageByLocation(d->resourceLocation);
 }
 
 KisResourceStorageSP KisResourceLocator::memoryStorage() const
 {
-    return storageByName("memory");
+    return storageByLocation("memory");
 }
 
 KisResourceLocator::ResourceStorage KisResourceLocator::getResourceStorage(int resourceId) const
 {
     ResourceStorage rs;
 
     QSqlQuery q;
     bool r = q.prepare("SELECT storages.location\n"
                        ",      resource_types.name as resource_type\n"
                        ",      resources.filename\n"
                        "FROM   resources\n"
                        ",      storages\n"
                        ",      resource_types\n"
                        "WHERE  resources.id = :resource_id\n"
                        "AND    resources.storage_id = storages.id\n"
                        "AND    resource_types.id = resources.resource_type_id");
     if (!r) {
         qWarning() << "KisResourceLocator::removeResource: could not prepare query." << q.lastError();
         return rs;
     }
 
 
     q.bindValue(":resource_id", resourceId);
 
     r = q.exec();
     if (!r) {
         qWarning() << "KisResourceLocator::removeResource: could not execute query." << q.lastError();
         return rs;
     }
 
     q.first();
 
     QString storageLocation = q.value("location").toString();
     QString resourceType= q.value("resource_type").toString();
     QString resourceFilename = q.value("filename").toString();
 
     if (storageLocation.isEmpty()) {
         storageLocation = resourceLocationBase();
     }
     else {
         storageLocation = resourceLocationBase() + storageLocation;
     }
 
     rs.storageLocation = storageLocation;
     rs.resourceType = resourceType;
     rs.resourceFileName = resourceFilename;
 
     return rs;
 }
 
 QString KisResourceLocator::makeStorageLocationAbsolute(QString storageLocation) const
 {
     if (storageLocation.isEmpty()) {
         storageLocation = resourceLocationBase();
     }
     if (!storageLocation.startsWith('/') && storageLocation != "memory") {
 
         if (resourceLocationBase().endsWith('/')) {
             storageLocation = resourceLocationBase() + storageLocation;
         }
         else {
             storageLocation = resourceLocationBase() + '/' + storageLocation;
         }
     }
     return storageLocation;
 }
 
 bool KisResourceLocator::synchronizeDb()
 {
     d->errorMessages.clear();
     findStorages();
     Q_FOREACH(const KisResourceStorageSP storage, d->storages) {
         if (!KisResourceCacheDb::synchronizeStorage(storage)) {
             d->errorMessages.append(i18n("Could not synchronize %1 with the database", storage->location()));
         }
     }
     return d->errorMessages.isEmpty();
 }
 
 
 QString KisResourceLocator::makeStorageLocationRelative(QString location) const
 {
     return location.remove(resourceLocationBase());
 }
diff --git a/libs/resources/KisResourceLocator.h b/libs/resources/KisResourceLocator.h
index c8cac02fcc..409116dce2 100644
--- a/libs/resources/KisResourceLocator.h
+++ b/libs/resources/KisResourceLocator.h
@@ -1,239 +1,240 @@
 /*
  * Copyright (C) 2018 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.
  */
 
 #ifndef KISRESOURCELOCATOR_H
 #define KISRESOURCELOCATOR_H
 
 #include <QObject>
 #include <QScopedPointer>
 #include <QStringList>
 #include <QString>
 
 #include "kritaresources_export.h"
 
 #include <KisResourceStorage.h>
 
 
 /**
  * The KisResourceLocator class locates all resource storages (folders,
  * bundles, various adobe resource libraries) in the resource location.
  *
  * The resource location is always a writable folder.
  *
  * There is one resource locator which is owned by the QApplication
  * object.
  *
  * The resource location is configurable, but there is only one location
  * where Krita will look for resources.
  */
 class KRITARESOURCES_EXPORT KisResourceLocator : public QObject
 {
     Q_OBJECT
 public:
 
     // The configuration key that holds the resource location
     // for this installation of Krita. The location is
     // QStandardPaths::AppDataLocation by default, but that
     // can be changed.
     static const QString resourceLocationKey;
 
     static KisResourceLocator *instance();
 
     ~KisResourceLocator();
 
     enum class LocatorError {
         Ok,
         LocationReadOnly,
         CannotCreateLocation,
         CannotInitializeDb,
         CannotSynchronizeDb
     };
 
     /**
      * @brief initialize Setup the resource locator for use.
      *
      * @param installationResourcesLocation the place where the resources
      * that come packaged with Krita reside.
      */
     LocatorError initialize(const QString &installationResourcesLocation);
 
     /**
      * @brief errorMessages
      * @return
      */
     QStringList errorMessages() const;
 
     /**
      * @brief resourceLocationBase is the place where all resource storages (folder,
      * bundles etc. are located. This is a writable place.
      * @return the base location for all storages.
      */
     QString resourceLocationBase() const;
 
     /**
      * @brief purge purges the local resource cache
      */
     void purge();
 
     /**
      * @brief addStorage Adds a new resource storage to the database. The storage is
      * will be marked as not pre-installed.
      * @param storageLocation a unique name for the given storage
      * @param storage a storage object
      * @return true if the storage has been added succesfully
      */
     bool addStorage(const QString &storageLocation, KisResourceStorageSP storage);
 
     /**
      * @brief removeStorage removes the temporary storage from the database
      * @param document the unique name of the document
      * @return true is succesful.
      */
     bool removeStorage(const QString &storageLocation);
 
     /**
      * @brief hasStorage can be used to check whether the given storage already exists
      * @param storageLocation the name of the storage
      * @return true if the storage is known
      */
     bool hasStorage(const QString &storageLocation);
 
 Q_SIGNALS:
 
     void progressMessage(const QString&);
 
 private:
 
     friend class KisResourceModel;
+    friend class KisStorageModel;
     friend class TestResourceLocator;
     friend class TestResourceModel;
     friend class Resource;
     friend class KisResourceCacheDb;
 
     /// @return true if the resource is present in the cache, false if it hasn't been loaded
     bool resourceCached(QString storageLocation, const QString &resourceType, const QString &filename) const;
 
     /**
      * @brief resource finds a physical resource in one of the storages
      * @param storageLocation the storage containing the resource. If empty,
      * this is the folder storage.
      *
      * Note that the resource does not have the version or id field set, so this cannot be used directly,
      * but only through KisResourceModel.
      *
      * @param resourceType the type of the resource
      * @param filename the filename of the resource including extension, but withou
      * any paths
      * @return A resource if found, or 0
      */
     KoResourceSP resource(QString storageLocation, const QString &resourceType, const QString &filename);
 
     /**
      * @brief resourceForId returns the resource with the given id, or 0 if no such resource exists.
      * The resource object will have its id set but not its version.
      * @param resourceId the id
      */
     KoResourceSP resourceForId(int resourceId);
 
     /**
      * @brief removeResource
      * @param resourceId
      * @param optional: the storage that contains the given resource
      * @return
      */
     bool removeResource(int resourceId, const QString &storageLocation = QString());
 
     /**
      * @brief importResourceFromFile
      * @param resourceType
      * @param fileName
      * @param storageLocation: optional, the storage where the resource will be stored. Empty means in the default Folder storage.
      * @return
      */
     bool importResourceFromFile(const QString &resourceType, const QString &fileName, const QString &storageLocation = QString());
 
     /**
      * @brief addResource adds the given resource to the database and potentially a storage
      * @param resourceType the type of the resource
      * @param resource the actual resource object
      * @param storageLocation the storage where the resource will be saved. By default this is the the default folder storage.
      * @return true if succesfull
      */
     bool addResource(const QString &resourceType, const KoResourceSP resource, const QString &storageLocation = QString());
 
     /**
      * @brief updateResource
      * @param resourceType
      * @param resource
      * @return
      */
     bool updateResource(const QString &resourceType, const KoResourceSP resource);
 
     /**
      * @brief metaDataForResource
      * @param id
      * @return
      */
     QMap<QString, QVariant> metaDataForResource(int id) const;
 
     bool setMetaDataForResource(int id, QMap<QString, QVariant> map) const;
 
     KisResourceLocator(QObject *parent);
     KisResourceLocator(const KisResourceLocator&);
     KisResourceLocator operator=(const KisResourceLocator&);
 
     enum class InitalizationStatus {
         Unknown,      // We don't know whether Krita has run on this system for this resource location yet
         Initialized,  // Everything is ready to start synchronizing the database
         FirstRun,     // Krita hasn't run for this resource location yet
         FirstUpdate,  // Krita was installed, but it's a version from before the resource locator existed, only user-defined resources are present
         Updating      // Krita is updating from an older version with resource locator
     };
 
     LocatorError firstTimeInstallation(InitalizationStatus initalizationStatus, const QString &installationResourcesLocation);
 
     // First time installation
     bool initializeDb();
 
     // Synchronize on restarting Krita to see whether the user has added any storages or resources to the resources location
     bool synchronizeDb();
 
     void findStorages();
     QList<KisResourceStorageSP> storages() const;
 
-    KisResourceStorageSP storageByName(const QString &name) const;
+    KisResourceStorageSP storageByLocation(const QString &location) const;
     KisResourceStorageSP folderStorage() const;
     KisResourceStorageSP memoryStorage() const;
 
     struct ResourceStorage {
         QString storageLocation;
         QString resourceType;
         QString resourceFileName;
     };
 
     ResourceStorage getResourceStorage(int resourceId) const;
     QString makeStorageLocationAbsolute(QString storageLocation) const;
     QString makeStorageLocationRelative(QString location) const;
 
 
     class Private;
     QScopedPointer<Private> d;
 };
 
 #endif // KISRESOURCELOCATOR_H
diff --git a/libs/resources/KisStorageModel.cpp b/libs/resources/KisStorageModel.cpp
index f4308c3143..b2ed43d923 100644
--- a/libs/resources/KisStorageModel.cpp
+++ b/libs/resources/KisStorageModel.cpp
@@ -1,187 +1,193 @@
 /*
  * Copyright (c) 2019 boud <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 "KisStorageModel.h"
 
 #include <QtSql>
 
+#include <KisResourceLocator.h>
 
 Q_GLOBAL_STATIC(KisStorageModel, s_instance)
 
 struct KisStorageModel::Private {
     int cachedRowCount {-1};
     QSqlQuery query;
 };
 
 KisStorageModel::KisStorageModel(QObject *parent)
     : QAbstractTableModel(parent)
     , d(new Private())
 {
     prepareQuery();
 }
 
 KisStorageModel *KisStorageModel::instance()
 {
     return s_instance;
 }
 
 KisStorageModel::~KisStorageModel()
 {
 }
 
 int KisStorageModel::rowCount(const QModelIndex & /*parent*/) const
 {
     if (d->cachedRowCount < 0) {
         QSqlQuery q;
         q.prepare("SELECT count(*)\n"
                   "FROM   storages\n");
         q.exec();
         q.first();
 
         const_cast<KisStorageModel*>(this)->d->cachedRowCount = q.value(0).toInt();
     }
     return d->cachedRowCount;
 }
 
 int KisStorageModel::columnCount(const QModelIndex &/*parent*/) const
 {
     return 6;
 }
 
 QVariant KisStorageModel::data(const QModelIndex &index, int role) const
 {
     QVariant v;
     if (!index.isValid()) return v;
     if (index.row() > rowCount()) return v;
     if (index.column() > (int)Active) return v;
 
     bool pos = d->query.seek(index.row());
 
     if (pos) {
         switch(role) {
         case Qt::DisplayRole:
         {
             switch(index.column()) {
             case Id:
                 return d->query.value("id");
             case StorageType:
                 return d->query.value("storage_type");
             case Location:
                 return d->query.value("location");
             case TimeStamp:
                return d->query.value("timestamp");
             case PreInstalled:
                 return d->query.value("pre_installed");
             case Active:
                 return d->query.value("active");
             case Thumbnail:
             {
                 QByteArray ba = d->query.value("thumbnail").toByteArray();
                 QBuffer buf(&ba);
                 buf.open(QBuffer::ReadOnly);
                 QImage img;
                 img.load(&buf, "PNG");
                 return QVariant::fromValue<QImage>(img);
             }
             default:
                 return v;
             }
         }
         case Qt::UserRole + Id:
             return d->query.value("id");
         case Qt::UserRole + StorageType:
             return d->query.value("storage_type");
         case Qt::UserRole + Location:
             return d->query.value("location");
         case Qt::UserRole + TimeStamp:
            return d->query.value("timestamp");
         case Qt::UserRole + PreInstalled:
             return d->query.value("pre_installed");
         case Qt::UserRole + Active:
             return d->query.value("active");
         case Qt::UserRole + Thumbnail:
         {
             QByteArray ba = d->query.value("thumbnail").toByteArray();
             QBuffer buf(&ba);
             buf.open(QBuffer::ReadOnly);
             QImage img;
             img.load(&buf, "PNG");
             return QVariant::fromValue<QImage>(img);
         }
         default:
             ;
         }
     }
     return v;
 
 }
 
 bool KisStorageModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (index.isValid()) {
         if (role == Qt::CheckStateRole) {
             QSqlQuery q;
             bool r = q.prepare("UPDATE storages\n"
                                "SET    active = :active\n"
                                "WHERE  id = :id\n");
             q.bindValue(":active", value);
             q.bindValue(":id", index.data(Qt::UserRole + Id));
             if (!r) {
                 qWarning() << "Could not prepare KisStorageModel update query" << d->query.lastError();
                 return false;
             }
             r = q.exec();
             if (!r) {
                 qWarning() << "Could not execute KisStorageModel update query" << d->query.lastError();
                 return false;
             }
 
         }
     }
     QAbstractTableModel::setData(index, value, role);
     return prepareQuery();
 }
 
 Qt::ItemFlags KisStorageModel::flags(const QModelIndex &index) const
 {
     return QAbstractTableModel::flags(index) | Qt::ItemIsEditable;
 }
 
+KisResourceStorageSP KisStorageModel::storageForId(const QModelIndex &index) const
+{
+    return KisResourceLocator::instance()->storageByLocation(index.data(Qt::UserRole + Location).toString());
+}
+
 bool KisStorageModel::prepareQuery()
 {
     beginResetModel();
     bool r = d->query.prepare("SELECT storages.id as id\n"
                               ",      storage_types.name as storage_type\n"
                               ",      location\n"
                               ",      timestamp\n"
                               ",      pre_installed\n"
                               ",      active\n"
                               ",      thumbnail\n"
                               "FROM   storages\n"
                               ",      storage_types\n"
                               "WHERE  storages.storage_type_id = storage_types.id\n");
     if (!r) {
         qWarning() << "Could not prepare KisStorageModel query" << d->query.lastError();
     }
     r = d->query.exec();
     if (!r) {
         qWarning() << "Could not execute KisStorageModel query" << d->query.lastError();
     }
     d->cachedRowCount = -1;
     endResetModel();
     return r;
 }
diff --git a/libs/resources/KisStorageModel.h b/libs/resources/KisStorageModel.h
index 338d3fc021..61c47be1b3 100644
--- a/libs/resources/KisStorageModel.h
+++ b/libs/resources/KisStorageModel.h
@@ -1,65 +1,68 @@
 /*
  * Copyright (c) 2019 boud <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.
  */
 #ifndef KISSTORAGEMODEL_H
 #define KISSTORAGEMODEL_H
 
 #include <QAbstractTableModel>
 #include <QObject>
 #include <QScopedPointer>
 
+#include "KisResourceStorage.h"
 #include "kritaresources_export.h"
 
 class KRITARESOURCES_EXPORT KisStorageModel : public QAbstractTableModel
 {
 public:
 
     enum Columns {
         Id = 0,
         StorageType,
         Location,
         TimeStamp,
         PreInstalled,
         Active,
         Thumbnail
     };
 
     static KisStorageModel * instance();
 
     KisStorageModel(QObject *parent = 0);
     ~KisStorageModel() override;
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     bool setData(const QModelIndex &index, const QVariant &value, int role) override;
     Qt::ItemFlags flags(const QModelIndex &index) const override;
 
+    KisResourceStorageSP storageForId(const QModelIndex &index) const;
+
 private:
 
     KisStorageModel(const KisStorageModel&);
     KisStorageModel operator=(const KisStorageModel&);
 
     bool prepareQuery();
 
     struct Private;
     QScopedPointer<Private> d;
 
 
 };
 
 #endif // KISSTORAGEMODEL_H