diff --git a/libs/resources/KisResourceLocator.cpp b/libs/resources/KisResourceLocator.cpp
index e5d3eac34a..265581f6b4 100644
--- a/libs/resources/KisResourceLocator.cpp
+++ b/libs/resources/KisResourceLocator.cpp
@@ -1,555 +1,591 @@
 /*
  * 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];
         if (!storage) {
             qWarning() << "Could not find storage" << storageLocation;
             return 0;
         }
 
         resource = storage->resource(resourceType + "/" + filename);
         if (!resource) {
             qWarning() << "Could not find resource" << resourceType + "/" + filename;
             return 0;
         }
         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);
     if (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();
 
     // This increments the version in the resource
     if (!storage->addResource(resource)) {
         qWarning() << "Failed to save the new version of " << resource->name() << "to storage" << storageLocation;
         return false;
     }
 
     // Memory storages don't store versioned resources
     if (storage->type() == KisResourceStorage::StorageType::Memory) {
         return true;
     }
 
     // It's the storages that keep track of the version
     Q_ASSERT(resource->version() == version + 1);
 
     // The version needs already to have been incremented
     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;
 }
 
+bool KisResourceLocator::renameResource(const KoResourceSP resource, const QString &name)
+{
+    resource->setName(name);
+
+    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();
+
+    // This increments the version in the resource
+    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);
+
+    // The version needs already to have been incremented
+    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, resource->resourceType().first + "/" + 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::storageByLocation(const QString &location) const
 {
     if (!d->storages.contains(location)) {
         qWarning() << "No" << location << "storage defined";
         return 0;
     }
     KisResourceStorageSP storage = d->storages[location];
     if (!storage || !storage->valid()) {
         qWarning() << "Could not retrieve the" << location << "storage object or the object is not valid";
         return 0;
     }
 
     return storage;
 }
 
 KisResourceStorageSP KisResourceLocator::folderStorage() const
 {
     return storageByLocation(d->resourceLocation);
 }
 
 KisResourceStorageSP KisResourceLocator::memoryStorage() const
 {
     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();
 
     rs.storageLocation = makeStorageLocationAbsolute(storageLocation);
     rs.resourceType = resourceType;
     rs.resourceFileName = resourceFilename;
 
     return rs;
 }
 
 QString KisResourceLocator::makeStorageLocationAbsolute(QString storageLocation) const
 {
     if (storageLocation.isEmpty()) {
         storageLocation = resourceLocationBase();
     }
 
     // XXX: This breaks with document storages!
 
     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 6f3b43d4bd..4adb7f3a70 100644
--- a/libs/resources/KisResourceLocator.h
+++ b/libs/resources/KisResourceLocator.h
@@ -1,241 +1,249 @@
 /*
  * 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 KisTagModel;
     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 renameResource
+     * @param resource
+     * @param name
+     * @return
+     */
+    bool renameResource(const KoResourceSP resource, const QString &name);
+
     /**
      * @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 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/KisResourceModel.cpp b/libs/resources/KisResourceModel.cpp
index 5ec61cf376..7b753f8df6 100644
--- a/libs/resources/KisResourceModel.cpp
+++ b/libs/resources/KisResourceModel.cpp
@@ -1,566 +1,579 @@
 /*
  * 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 "KisResourceModel.h"
 
 #include <QTime>
 #include <QBuffer>
 #include <QImage>
 #include <QtSql>
 #include <QStringList>
 
 #include <KisResourceLocator.h>
 #include <KisResourceCacheDb.h>
 
 #include <KisTagModelProvider.h>
 
 
 
 struct KisResourceModel::Private {
     QSqlQuery resourcesQuery;
     QSqlQuery tagQuery;
     QString resourceType;
     int columnCount {9};
     int cachedRowCount {-1};
 };
 
 
 //static int s_i = 0;
 
 KisResourceModel::KisResourceModel(const QString &resourceType, QObject *parent)
     : QAbstractTableModel(parent)
     , d(new Private)
 {
     //qDebug() << "ResourceModel" << s_i << resourceType; s_i++;
 
     d->resourceType = resourceType;
     
     bool r = d->resourcesQuery.prepare("SELECT resources.id\n"
                                        ",      resources.storage_id\n"
                                        ",      resources.name\n"
                                        ",      resources.filename\n"
                                        ",      resources.tooltip\n"
                                        ",      resources.thumbnail\n"
                                        ",      resources.status\n"
                                        ",      storages.location\n"
                                        ",      resources.version\n"
                                        ",      resource_types.name as resource_type\n"
                                        "FROM   resources\n"
                                        ",      resource_types\n"
                                        ",      storages\n"
                                        "WHERE  resources.resource_type_id = resource_types.id\n"
                                        "AND    resources.storage_id = storages.id\n"
                                        "AND    resource_types.name = :resource_type\n"
                                        "AND    resources.status = 1\n"
                                        "AND    storages.active = 1");
     if (!r) {
         qWarning() << "Could not prepare KisResourceModel query" << d->resourcesQuery.lastError();
     }
     d->resourcesQuery.bindValue(":resource_type", d->resourceType);
     
     resetQuery();
     
     r = d->tagQuery.prepare("SELECT tags.id\n"
                             ",      tags.url\n"
                             ",      tags.name\n"
                             ",      tags.comment\n"
                             "FROM   tags\n"
                             ",      resource_tags\n"
                             "WHERE  tags.active > 0\n"                               // make sure the tag is active
                             "AND    tags.id = resource_tags.tag_id\n"                // join tags + resource_tags by tag_id
                             "AND    resource_tags.resource_id = :resource_id\n");    // make sure we're looking for tags for a specific resource
     if (!r)  {
         qWarning() << "Could not prepare TagsForResource query" << d->tagQuery.lastError();
     }
     
 }
 
 KisResourceModel::~KisResourceModel()
 {
     delete d;
 }
 
 int KisResourceModel::columnCount(const QModelIndex &/*parent*/) const
 {
     return d->columnCount;
 }
 
 QVariant KisResourceModel::data(const QModelIndex &index, int role) const
 {
     
     QVariant v;
     if (!index.isValid()) return v;
     
     if (index.row() > rowCount()) return v;
     if (index.column() > d->columnCount) return v;
     
     bool pos = const_cast<KisResourceModel*>(this)->d->resourcesQuery.seek(index.row());
     
     if (pos) {
         switch(role) {
         case Qt::DisplayRole:
         {
             switch(index.column()) {
             case Id:
                 return d->resourcesQuery.value("id");
             case StorageId:
                 return d->resourcesQuery.value("storage_id");
             case Name:
                 return d->resourcesQuery.value("name");
             case Filename:
                 return d->resourcesQuery.value("filename");
             case Tooltip:
                 return d->resourcesQuery.value("tooltip");
             case Image:
             {
                 QByteArray ba = d->resourcesQuery.value("thumbnail").toByteArray();
                 QBuffer buf(&ba);
                 buf.open(QBuffer::ReadOnly);
                 QImage img;
                 img.load(&buf, "PNG");
                 return QVariant::fromValue<QImage>(img);
             }
             case Status:
                 return d->resourcesQuery.value("status");
             case Location:
                 return d->resourcesQuery.value("location");
             case ResourceType:
                 return d->resourcesQuery.value("resource_type");
             default:
                 ;
             };
             Q_FALLTHROUGH();
         }
         case Qt::DecorationRole:
         {
             if (index.column() == Image) {
                 QByteArray ba = d->resourcesQuery.value("thumbnail").toByteArray();
                 QBuffer buf(&ba);
                 buf.open(QBuffer::ReadOnly);
                 QImage img;
                 img.load(&buf, "PNG");
                 return QVariant::fromValue<QImage>(img);
             }
             return QVariant();
         }
         case Qt::ToolTipRole:
             Q_FALLTHROUGH();
         case Qt::StatusTipRole:
             Q_FALLTHROUGH();
         case Qt::WhatsThisRole:
             return d->resourcesQuery.value("tooltip");
         case Qt::UserRole + Id:
             return d->resourcesQuery.value("id");
         case Qt::UserRole + StorageId:
             return d->resourcesQuery.value("storage_id");
         case Qt::UserRole + Name:
             return d->resourcesQuery.value("name");
         case Qt::UserRole + Filename:
             return d->resourcesQuery.value("filename");
         case Qt::UserRole + Tooltip:
             return d->resourcesQuery.value("tooltip");
         case Qt::UserRole + Image:
         {
             QByteArray ba = d->resourcesQuery.value("thumbnail").toByteArray();
             QBuffer buf(&ba);
             buf.open(QBuffer::ReadOnly);
             QImage img;
             img.load(&buf, "PNG");
             return QVariant::fromValue<QImage>(img);
         }
         case Qt::UserRole + Status:
             return d->resourcesQuery.value("status");
         case Qt::UserRole + Location:
             return d->resourcesQuery.value("location");
         case Qt::UserRole + ResourceType:
             return d->resourcesQuery.value("resource_type");
         case Qt::UserRole + Tags:
         {
             QVector<KisTagSP> tags = tagsForResource(d->resourcesQuery.value("id").toInt());
             QStringList tagNames;
             Q_FOREACH(const KisTagSP tag, tags) {
                 tagNames << tag->name();
             }
             return tagNames;
         }
         case Qt::UserRole + Dirty:
         {
             QString storageLocation = d->resourcesQuery.value("location").toString();
             QString filename = d->resourcesQuery.value("filename").toString();
             
             // An uncached resource has not been loaded, so it cannot be dirty
             if (!KisResourceLocator::instance()->resourceCached(storageLocation, d->resourceType, filename)) {
                 return false;
             }
             else {
                 // Now we have to check the resource, but that's cheap since it's been loaded in any case
                 KoResourceSP resource = resourceForIndex(index);
                 return resource->isDirty();
             }
         }
         case Qt::UserRole + MetaData:
         {
             QMap<QString, QVariant> r = KisResourceLocator::instance()->metaDataForResource(d->resourcesQuery.value("id").toInt());
             return r;
         }
         case Qt::UserRole + KoResourceRole:
         {
             KoResourceSP tag = resourceForIndex(index);
             QVariant response;
             response.setValue(tag);
             return response;
         }
             
         default:
             ;
         }
     }
     return v;
 }
 
 QVariant KisResourceModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     QVariant v = QVariant();
     if (role != Qt::DisplayRole) {
         return v;
     }
     if (orientation == Qt::Horizontal) {
         switch(section) {
         case Id:
             v = i18n("Id");
             break;
         case StorageId:
             v = i18n("Storage ID");
             break;
         case Name:
             v = i18n("Name");
             break;
         case Filename:
             v = i18n("File Name");
             break;
         case Tooltip:
             v = i18n("Tooltip");
             break;
         case Image:
             v = i18n("Image");
             break;
         case Status:
             v = i18n("Status");
             break;
         case Location:
             v = i18n("Location");
             break;
         case ResourceType:
             v = i18n("Resource Type");
             break;
         default:
             v = QString::number(section);
         }
         return v;
     }
     return QAbstractItemModel::headerData(section, orientation, role);
 }
 
 //static int s_i2 {0};
 
 KoResourceSP KisResourceModel::resourceForIndex(QModelIndex index) const
 {
     KoResourceSP resource = 0;
     
     if (!index.isValid()) return resource;
     if (index.row() > rowCount()) return resource;
     if (index.column() > d->columnCount) return resource;
 
     //qDebug() << "KisResourceModel::resourceForIndex" << s_i2 << d->resourceType; s_i2++;
 
     bool pos = const_cast<KisResourceModel*>(this)->d->resourcesQuery.seek(index.row());
     if (pos) {
         QString storageLocation = d->resourcesQuery.value("location").toString();
         QString filename = d->resourcesQuery.value("filename").toString();
         resource = KisResourceLocator::instance()->resource(storageLocation, d->resourceType, filename);
         resource->setResourceId(d->resourcesQuery.value("id").toInt());
         resource->setVersion(d->resourcesQuery.value("version").toInt());
         resource->setFilename(filename);
         resource->setStorageLocation(storageLocation);
         QString name = d->resourcesQuery.value("name").toString();
         if (!name.isNull()) {
             resource->setName(name);
         }
     }
     return resource;
 }
 
 KoResourceSP KisResourceModel::resourceForId(int id) const
 {
     return KisResourceLocator::instance()->resourceForId(id);
 }
 
 KoResourceSP KisResourceModel::resourceForFilename(QString filename) const
 {
     KoResourceSP resource = 0;
 
     QSqlQuery q;
     bool r = q.prepare("SELECT resources.id AS id\n"
                        "FROM   resources\n"
                        ",      resource_types\n"
                        ",      storages\n"
                        "WHERE  resources.resource_type_id = resource_types.id\n"
                        "AND    resources.storage_id = storages.id\n"
                        "AND    resources.filename = :resource_filename\n"
                        "AND    resource_types.name = :resource_type\n"
                        "AND    resources.status = 1\n"
                        "AND    storages.active = 1");
     if (!r) {
         qWarning() << "Could not prepare KisResourceModel query for resource name" << q.lastError();
     }
     q.bindValue(":resource_filename", filename);
     q.bindValue(":resource_type", d->resourceType);
 
     r = q.exec();
     if (!r) {
         qWarning() << "Could not select" << d->resourceType << "resources by filename" << q.lastError() << q.boundValues();
     }
 
     if (q.first()) {
         int id = q.value("id").toInt();
         resource = KisResourceLocator::instance()->resourceForId(id);
     }
     return resource;
 }
 
 KoResourceSP KisResourceModel::resourceForName(QString name) const
 {
     KoResourceSP resource = 0;
 
     QSqlQuery q;
     bool r = q.prepare("SELECT resources.id AS id\n"
                        "FROM   resources\n"
                        ",      resource_types\n"
                        ",      storages\n"
                        "WHERE  resources.resource_type_id = resource_types.id\n"
                        "AND    resources.storage_id = storages.id\n"
                        "AND    resources.name = :resource_name\n"
                        "AND    resource_types.name = :resource_type\n"
                        "AND    resources.status = 1\n"
                        "AND    storages.active = 1");
     if (!r) {
         qWarning() << "Could not prepare KisResourceModel query for resource name" << q.lastError();
     }
     q.bindValue(":resource_type", d->resourceType);
     q.bindValue(":resource_name", name);
 
     r = q.exec();
     if (!r) {
         qWarning() << "Could not select" << d->resourceType << "resources by name" << q.lastError() << q.boundValues();
     }
 
     if (q.first()) {
         int id = q.value("id").toInt();
         resource = KisResourceLocator::instance()->resourceForId(id);
     }
     return resource;
 }
 
 
 KoResourceSP KisResourceModel::resourceForMD5(const QByteArray md5sum) const
 {
     KoResourceSP resource = 0;
 
     QSqlQuery q;
     bool r = q.prepare("SELECT resource_id AS id\n"
                        "FROM   versioned_resources\n"
                        "WHERE  md5sum = :md5sum");
     if (!r) {
         qWarning() << "Could not prepare KisResourceModel query for resource md5" << q.lastError();
     }
     q.bindValue(":md5sum", md5sum.toHex());
 
     r = q.exec();
     if (!r) {
         qWarning() << "Could not select" << d->resourceType << "resources by md5" << q.lastError() << q.boundValues();
     }
 
     if (q.first()) {
         int id = q.value("id").toInt();
         resource = KisResourceLocator::instance()->resourceForId(id);
     }
     return resource;
 }
 
 //static int s_i3 {0};
 
 QModelIndex KisResourceModel::indexFromResource(KoResourceSP resource) const
 {
     if (!resource || !resource->valid()) return QModelIndex();
 
     //qDebug() << "KisResourceModel::indexFromResource" << s_i3 << d->resourceType; s_i3++;
     
     // For now a linear seek to find the first resource with the right id
     d->resourcesQuery.first();
     do {
         if (d->resourcesQuery.value("id").toInt() == resource->resourceId()) {
             return createIndex(d->resourcesQuery.at(), 0);
         }
     } while (d->resourcesQuery.next());
     
     return QModelIndex();
 }
 
 //static int s_i4 {0};
 
 bool KisResourceModel::removeResource(const QModelIndex &index)
 {
     if (index.row() > rowCount()) return false;
     if (index.column() > d->columnCount) return false;
     
     //qDebug() << "KisResourceModel::removeResource" << s_i4 << d->resourceType; s_i4++;
 
     bool pos = d->resourcesQuery.seek(index.row());
     if (!pos) return false;
     
     int resourceId = d->resourcesQuery.value("id").toInt();
     if (!KisResourceLocator::instance()->removeResource(resourceId)) {
         qWarning() << "Failed to remove resource" << resourceId;
         return false;
     }
     return resetQuery();
 }
 
 //static int s_i5 {0};
 
 bool KisResourceModel::removeResource(KoResourceSP resource)
 {
     if (!resource || !resource->valid()) return false;
 
     //qDebug() << "KisResourceModel::remvoeResource 2" << s_i5 << d->resourceType; s_i5++;
 
     if (!KisResourceLocator::instance()->removeResource(resource->resourceId())) {
         qWarning() << "Failed to remove resource" << resource->resourceId();
         return false;
     }
     return resetQuery();
 }
 
 //static int s_i6 {0};
 
 bool KisResourceModel::importResourceFile(const QString &filename)
 {
     //qDebug() << "KisResourceModel::importResource" << s_i6 << d->resourceType; s_i6++;
 
     if (!KisResourceLocator::instance()->importResourceFromFile(d->resourceType, filename)) {
         qWarning() << "Failed to import resource" << filename;
         return false;
     }
     return resetQuery();
 }
 
 //static int s_i7 {0};
 
 bool KisResourceModel::addResource(KoResourceSP resource, const QString &storageId)
 {
     if (!resource || !resource->valid()) {
         qWarning() << "Cannot add resource. Resource is null or not valid";
         return false;
     }
 
     //qDebug() << "KisResourceModel::addResource" << s_i7 << d->resourceType; s_i7++;
 
     if (!KisResourceLocator::instance()->addResource(d->resourceType, resource, storageId)) {
         qWarning() << "Failed to add resource" << resource->name();
         return false;
     }
     return resetQuery();
 }
 
 //static int s_i8 {0};
 
 bool KisResourceModel::updateResource(KoResourceSP resource)
 {
     if (!resource || !resource->valid()) {
         qWarning() << "Cannot update resource. Resource is null or not valid";
         return false;
     }
 
     //qDebug() << "KisResourceModel::updateResource" << s_i8 << d->resourceType; s_i8++;
 
     if (!KisResourceLocator::instance()->updateResource(d->resourceType, resource)) {
-        qWarning() << "Failed to update resource";
+        qWarning() << "Failed to update resource" << resource;
+        return false;
+    }
+    return resetQuery();
+}
+
+bool KisResourceModel::renameResource(KoResourceSP resource, const QString &name)
+{
+    if (!resource || !resource->valid() || name.isEmpty()) {
+        qWarning() << "Cannot rename resources. Resource is NULL or not valid or name is empty";
+        return false;
+    }
+    if (!KisResourceLocator::instance()->renameResource(resource, name)) {
+        qWarning() << "Failed to rename resource" << resource << name;
         return false;
     }
     return resetQuery();
 }
 
 //static int s_i9 {0};
 
 bool KisResourceModel::setResourceMetaData(KoResourceSP resource, QMap<QString, QVariant> metadata)
 {
     //qDebug() << "KisResourceModel::setResourceMetaData" << s_i9 << d->resourceType; s_i9++;
     Q_ASSERT(resource->resourceId() > -1);
     return KisResourceLocator::instance()->setMetaDataForResource(resource->resourceId(), metadata);
 }
 
 bool KisResourceModel::resetQuery()
 {
     QTime t;
     t.start();
 
     emit beforeResourcesLayoutReset(QModelIndex());
 
     beginResetModel();
     bool r = d->resourcesQuery.exec();
     if (!r) {
         qWarning() << "Could not select" << d->resourceType << "resources" << d->resourcesQuery.lastError() << d->resourcesQuery.boundValues();
     }
     d->cachedRowCount = -1;
 
     endResetModel();
     emit afterResourcesLayoutReset();
 
     qDebug() << "KisResourceModel::resetQuery for" << d->resourceType << "took" << t.elapsed() << "ms";
 
     return r;
 }
 
 QVector<KisTagSP> KisResourceModel::tagsForResource(int resourceId) const
 {
     return KisTagModelProvider::tagModel(d->resourceType)->tagsForResource(resourceId);
 }
 
 int KisResourceModel::rowCount(const QModelIndex &) const
 {
     if (d->cachedRowCount < 0) {
         QSqlQuery q;
         q.prepare("SELECT count(*)\n"
                   "FROM   resources\n"
                   ",      resource_types\n"
                   ",      storages\n"
                   "WHERE  resources.resource_type_id = resource_types.id\n"
                   "AND    resource_types.name = :resource_type\n"
                   "AND    resources.storage_id = storages.id\n"
                   "AND    resources.status = 1\n"
                   "AND    storages.active = 1");
         q.bindValue(":resource_type", d->resourceType);
         q.exec();
         q.first();
         
         const_cast<KisResourceModel*>(this)->d->cachedRowCount = q.value(0).toInt();
     }
     
     return d->cachedRowCount;
 }
diff --git a/libs/resources/KisResourceModel.h b/libs/resources/KisResourceModel.h
index 20ce1a411e..40430426fd 100644
--- a/libs/resources/KisResourceModel.h
+++ b/libs/resources/KisResourceModel.h
@@ -1,200 +1,209 @@
 /*
  * 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 KISRESOURCEMODEL_H
 #define KISRESOURCEMODEL_H
 
 #include <QAbstractTableModel>
 
 #include <kritaresources_export.h>
 
 #include <KoResource.h>
 #include <KisTag.h>
 
 class KRITARESOURCES_EXPORT KisAbstractResourceModel {
 
 public:
 
     virtual ~KisAbstractResourceModel(){}
 
     /**
      * @brief resourceForIndex
      * @param index
      * @return
      */
     virtual KoResourceSP resourceForIndex(QModelIndex index = QModelIndex()) const = 0;
 
     /**
      * @brief indexFromResource
      * @param resource
      * @return
      */
     virtual QModelIndex indexFromResource(KoResourceSP resource) const = 0;
 
     /**
      * @brief removeResource
      * @param index
      * @return
      */
     virtual bool removeResource(const QModelIndex &index) = 0;
 
     /**
      * @brief importResourceFile
      * @param filename
      * @return
      */
     virtual bool importResourceFile(const QString &filename) = 0;
 
     /**
      * @brief addResource adds the given resource to the database and storage
      * @param resource the resource itself
      * @param storageId the id of the storage (could be "memory" for temporary
      * resources, the document's storage id for document storages or empty to save
      * to the default resources folder
      * @return true if adding the resoruce succeded.
      */
     virtual bool addResource(KoResourceSP resource, const QString &storageId = QString()) = 0;
 
     /**
      * @brief updateResource
      * @param resource
      * @return
      */
     virtual bool updateResource(KoResourceSP resource) = 0;
 
+    /**
+     * @brief renameResource
+     * @param resource
+     * @param name
+     * @return
+     */
+    virtual bool renameResource(KoResourceSP resource, const QString &name) = 0;
+
     /**
      * @brief removeResource
      * @param resource
      * @return
      */
     virtual bool removeResource(KoResourceSP resource) = 0;
 
     /**
      * @brief setResourceMetaData
      * @param metadata
      * @return
      */
     virtual bool setResourceMetaData(KoResourceSP resource, QMap<QString, QVariant> metadata) = 0;
 };
 
 /**
  * @brief The KisResourceModel class provides access to the cache database
  * for a particular resource type. Instances should be retrieved using
  * KisResourceModelProvider.
  */
 class KRITARESOURCES_EXPORT KisResourceModel : public QAbstractTableModel, public KisAbstractResourceModel
 {
     Q_OBJECT
 public:
 
     /**
      * @brief The Columns enum indexes the columns in the model. To get
      * the thumbnail for a particular resource, create the index with
      * QModelIndex(row, Thumbnail).
      */
     enum Columns {
         Id = 0,
         StorageId,
         Name,
         Filename,
         Tooltip,
         Image,
         Status,
         Location,
         ResourceType,
         Tags,
         /// A larger thumbnail for displaying in a tooltip. 200x200 or so.
         LargeThumbnail,
         /// A dirty resource is one that has been modified locally but not saved
         Dirty,
         /// MetaData is a map of key, value pairs that is associated with this resource
         MetaData,
         KoResourceRole
     };
 
 private:
     friend class KisResourceModelProvider;
     friend class TestResourceModel;
     KisResourceModel(const QString &resourceType, QObject *parent = 0);
 
 public:
 
     ~KisResourceModel() override;
 
 // QAbstractItemModel API
 
     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;
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
 
 // Resources API
     /**
      * @brief resourceForIndex returns a properly versioned and id's resource object
      */
     KoResourceSP resourceForIndex(QModelIndex index = QModelIndex()) const override;
     KoResourceSP resourceForId(int id) const;
 
     /**
      * resourceForFilename returns the first resource with the given filename that
      * is active and is in an active store. Note that the filename does not include
      * a path to the storage, and if there are resources with the same filename
      * in several active storages, only one resource is returned.
      *
      * @return a resource if one is found, or 0 if none are found
      */
     KoResourceSP resourceForFilename(QString fileName) const;
 
     /**
      * resourceForName returns the first resource with the given name that
      * is active and is in an active store. Note that if there are resources
      * with the same name in several active storages, only one resource
      * is returned.
      *
      * @return a resource if one is found, or 0 if none are found
      */
     KoResourceSP resourceForName(QString name) const;
     KoResourceSP resourceForMD5(const QByteArray md5sum) const;
 
     QModelIndex indexFromResource(KoResourceSP resource) const override;
     bool removeResource(const QModelIndex &index) override;
     bool removeResource(KoResourceSP resource) override;
     bool importResourceFile(const QString &filename) override;
     bool addResource(KoResourceSP resource, const QString &storageId = QString()) override;
     bool updateResource(KoResourceSP resource) override;
+    bool renameResource(KoResourceSP resource, const QString &name) override;
     bool setResourceMetaData(KoResourceSP resource, QMap<QString, QVariant> metadata) override;
     QVector<KisTagSP> tagsForResource(int resourceId) const;
 
 
 Q_SIGNALS:
 
     // XXX: emit these signals
     void beforeResourcesLayoutReset(QModelIndex activateAfterReformat);
     void afterResourcesLayoutReset();
 
 private:
 
     bool resetQuery();
 
     struct Private;
     Private *const d;
 
 };
 
 #endif // KISRESOURCEMODEL_H
diff --git a/libs/resources/KisTagFilterResourceProxyModel.cpp b/libs/resources/KisTagFilterResourceProxyModel.cpp
index c1d84af8a3..ba827f86ab 100644
--- a/libs/resources/KisTagFilterResourceProxyModel.cpp
+++ b/libs/resources/KisTagFilterResourceProxyModel.cpp
@@ -1,233 +1,242 @@
 /*
  * 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 "KisTagFilterResourceProxyModel.h"
 
 #include <QDebug>
 #include <KisResourceModel.h>
 #include <kis_debug.h>
 #include <KisResourceSearchBoxFilter.h>
 
 struct KisTagFilterResourceProxyModel::Private
 {
     Private()
         : filter(new KisResourceSearchBoxFilter())
     {
     }
 
     QList<KisTagSP> tags;
     KisTagModel* tagModel;
     QScopedPointer<KisResourceSearchBoxFilter> filter;
 
 };
 
 KisTagFilterResourceProxyModel::KisTagFilterResourceProxyModel(KisTagModel* model, QObject *parent)
     : QSortFilterProxyModel(parent)
     , d(new Private)
 {
     d->tagModel = model;
     //connect(model, SIGNAL(modelReset()), this, SLOT(slotModelReset()));
 }
 
 KisTagFilterResourceProxyModel::~KisTagFilterResourceProxyModel()
 {
     delete d;
 }
 
 KoResourceSP KisTagFilterResourceProxyModel::resourceForIndex(QModelIndex index) const
 {
     KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
     if (source) {
         return source->resourceForIndex(mapToSource(index));
     }
     return 0;
 }
 
 QModelIndex KisTagFilterResourceProxyModel::indexFromResource(KoResourceSP resource) const
 {
     KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
     if (source) {
         return mapFromSource(source->indexFromResource(resource));
     }
     return QModelIndex();
 }
 
 bool KisTagFilterResourceProxyModel::removeResource(const QModelIndex &index)
 {
     KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
     if (source) {
         return source->removeResource(mapToSource(index));
     }
     return false;
 }
 
 bool KisTagFilterResourceProxyModel::importResourceFile(const QString &filename)
 {
     KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
     if (source) {
         return source->importResourceFile(filename);
     }
     return false;
 }
 
 bool KisTagFilterResourceProxyModel::addResource(KoResourceSP resource, const QString &storageId)
 {
     KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
     if (source) {
         return source->addResource(resource, storageId);
     }
     return false;
 }
 
 bool KisTagFilterResourceProxyModel::updateResource(KoResourceSP resource)
 {
     KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
     if (source) {
         return source->updateResource(resource);
     }
     return false;
 }
 
+bool KisTagFilterResourceProxyModel::renameResource(KoResourceSP resource, const QString &name)
+{
+    KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
+    if (source) {
+        return source->renameResource(resource, name);
+    }
+    return false;
+}
+
 bool KisTagFilterResourceProxyModel::removeResource(KoResourceSP resource)
 {
     KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
     if (source) {
         return source->removeResource(resource);
     }
     return false;
 }
 
 bool KisTagFilterResourceProxyModel::setResourceMetaData(KoResourceSP resource, QMap<QString, QVariant> metadata)
 {
     KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
     if (source) {
         return source->setResourceMetaData(resource, metadata);
     }
     return false;
 }
 
 void KisTagFilterResourceProxyModel::setTag(const KisTagSP tag)
 {
     ENTER_FUNCTION() << (tag.isNull() ? "(null)" : tag->name());
     //d->tags = tag.split(QRegExp("[,]\\s*"), QString::SkipEmptyParts);
     d->tags.clear();
     if (!tag.isNull()) {
         d->tags << tag;
     }
     invalidateFilter();
 }
 
 void KisTagFilterResourceProxyModel::setSearchBoxText(const QString& seatchBoxText)
 {
     d->filter->setFilter(seatchBoxText);
     invalidateFilter();
 }
 
 bool KisTagFilterResourceProxyModel::filterAcceptsColumn(int /*source_column*/, const QModelIndex &/*source_parent*/) const
 {
     return true;
 }
 
 bool KisTagFilterResourceProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
 {
     //fprintf(stderr, "1 ");
     if (d->tagModel == 0) {
         return true;
     }
     //fprintf(stderr, "2 ");
     QModelIndex idx = sourceModel()->index(source_row, KisResourceModel::Name, source_parent);
     int resourceId = sourceModel()->data(idx, Qt::UserRole + KisResourceModel::Id).toInt();
     QString resourceName = sourceModel()->data(idx, Qt::UserRole + KisResourceModel::Name).toString();
 
     //QStringList tags = sourceModel()->data(idx, Qt::UserRole + KisResourceModel::Tags).toStringList();
     QVector<KisTagSP> tagsForResource = d->tagModel->tagsForResource(resourceId);
 
     //QString name = sourceModel()->data(idx, Qt::UserRole + KisResourceModel::Tags).toString();
 
 
     // TODO: RESOURCES: proper filtering by tag
     //fprintf(stderr, "3 ");
     KisTagSP tag = d->tags.isEmpty() ? KisTagSP() : d->tags.first();
 
     bool hasCurrentTag = false;
     //fprintf(stderr, "4 ");
     //fprintf(stderr, "tag_first:_%s ", (tag.isNull() ? "(null)" : tag->name().toStdString().c_str()));
     if (tag.isNull()) {
         hasCurrentTag = true;
     }
     if (!hasCurrentTag && !tag.isNull()) {
         if (tag->id() == KisTagModel::All) {
             hasCurrentTag = true;
         } else if (tag->id() == KisTagModel::AllUntagged) {
             if (tagsForResource.size() == 0) {
                 hasCurrentTag = true;
             }
         }
     }
     //fprintf(stderr, "5-%d ", hasCurrentTag);
     if (!hasCurrentTag && !tag.isNull()) {
         Q_FOREACH(KisTagSP temp, tagsForResource) {
             if (temp->url() == tag->url()) {
                 hasCurrentTag = true;
                 break;
             }
         }
     }
     //fprintf(stderr, "6-%d ", hasCurrentTag);
 
     if (!hasCurrentTag) {
         //fprintf(stderr, "end :( \n");
         return false;
     }
     //fprintf(stderr, "7-%d ", hasCurrentTag);
 
     bool currentFilterMatches = d->filter->matchesResource(resourceName);
 
     //fprintf(stderr, "8-%d \n", hasCurrentTag);
     return currentFilterMatches;
 
     //sourceModel()->data(idx, )
 
     /*
     QSet<QString> tagResult = tags.toSet().subtract(tags.toSet());
     if (!tagResult.isEmpty()) {
         return true;
     }
 
     QString name = sourceModel()->data(idx, Qt::UserRole + KisResourceModel::Name).toString();
     Q_FOREACH(const KisTagSP &tag, d->tags) {
         if (name.startsWith(tag)) {
             return true;
         }
     }
     */
 
     return false;
 }
 
 bool KisTagFilterResourceProxyModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
 {
     QString nameLeft = sourceModel()->data(source_left, Qt::UserRole + KisResourceModel::Name).toString();
     QString nameRight = sourceModel()->data(source_right, Qt::UserRole + KisResourceModel::Name).toString();
     return nameLeft < nameRight;
 }
 
 void KisTagFilterResourceProxyModel::slotModelReset()
 {
     invalidateFilter();
 }
diff --git a/libs/resources/KisTagFilterResourceProxyModel.h b/libs/resources/KisTagFilterResourceProxyModel.h
index 6ecd390021..383e73ebf1 100644
--- a/libs/resources/KisTagFilterResourceProxyModel.h
+++ b/libs/resources/KisTagFilterResourceProxyModel.h
@@ -1,76 +1,77 @@
 /*
  * 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 KISTAGFILTERRESOURCEPROXYMODEL_H
 #define KISTAGFILTERRESOURCEPROXYMODEL_H
 
 #include <QSortFilterProxyModel>
 #include <QObject>
 #include <KoResource.h>
 #include <KisResourceModel.h>
 #include <KisTag.h>
 #include <KisTagModel.h>
 
 #include "kritaresources_export.h"
 
 class KRITARESOURCES_EXPORT KisTagFilterResourceProxyModel : public QSortFilterProxyModel, public KisAbstractResourceModel
 {
     Q_OBJECT
 public:
     KisTagFilterResourceProxyModel(KisTagModel* model = 0, QObject *parent = 0);
     ~KisTagFilterResourceProxyModel() override;
 
     // KisAbstractResourceModel interface
 public:
     KoResourceSP resourceForIndex(QModelIndex index = QModelIndex()) const override;
     QModelIndex indexFromResource(KoResourceSP resource) const override;
     bool removeResource(const QModelIndex &index) override;
     bool importResourceFile(const QString &filename) override;
     bool addResource(KoResourceSP resource, const QString &storageId = QString()) override;
     bool updateResource(KoResourceSP resource) override;
+    bool renameResource(KoResourceSP resource, const QString &name) override;
     bool removeResource(KoResourceSP resource) override;
     bool setResourceMetaData(KoResourceSP resource, QMap<QString, QVariant> metadata) override;
 
     /**
      * @brief setTag
      * @param tag
      */
     void setTag(const KisTagSP tag);
     void setSearchBoxText(const QString& seatchBoxText);
 
 protected:
 
 
 
     bool filterAcceptsColumn(int source_column, const QModelIndex &source_parent) const override;
     bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
     bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const override;
 
 private Q_SLOTS:
     void slotModelReset();
 
 
 private:
     struct Private;
     Private *const d;
 
     Q_DISABLE_COPY(KisTagFilterResourceProxyModel)
 };
 
 #endif // KISTAGFILTERRESOURCEPROXYMODEL_H
diff --git a/libs/resources/tests/TestResourceModel.cpp b/libs/resources/tests/TestResourceModel.cpp
index 203a3ddebe..f0e823b3df 100644
--- a/libs/resources/tests/TestResourceModel.cpp
+++ b/libs/resources/tests/TestResourceModel.cpp
@@ -1,277 +1,305 @@
 /*
  * Copyright (c) 2018 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 "TestResourceModel.h"
 
 #include <QTest>
 #include <QStandardPaths>
 #include <QDir>
 #include <QVersionNumber>
 #include <QDirIterator>
 #include <QSqlError>
 #include <QSqlQuery>
 #include <QTemporaryFile>
 #include <QDir>
 #include <QtSql>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <KisResourceCacheDb.h>
 #include <KisResourceLocator.h>
 #include <KisResourceLoaderRegistry.h>
 #include <KisResourceModel.h>
 
 #include <DummyResource.h>
 #include <ResourceTestHelper.h>
 
 #ifndef FILES_DATA_DIR
 #error "FILES_DATA_DIR not set. A directory with the data used for testing installing resources"
 #endif
 
 #ifndef FILES_DEST_DIR
 #error "FILES_DEST_DIR not set. A directory where data will be written to for testing installing resources"
 #endif
 
 
 void TestResourceModel::initTestCase()
 {
     ResourceTestHelper::initTestDb();
     ResourceTestHelper::createDummyLoaderRegistry();
 
     m_srcLocation = QString(FILES_DATA_DIR);
     QVERIFY2(QDir(m_srcLocation).exists(), m_srcLocation.toUtf8());
 
     m_dstLocation = QString(FILES_DEST_DIR);
     ResourceTestHelper::cleanDstLocation(m_dstLocation);
 
     KConfigGroup cfg(KSharedConfig::openConfig(), "");
     cfg.writeEntry(KisResourceLocator::resourceLocationKey, m_dstLocation);
 
     m_locator = KisResourceLocator::instance();
 
     if (!KisResourceCacheDb::initialize(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation))) {
         qWarning() << "Could not initialize KisResourceCacheDb on" << QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
     }
     QVERIFY(KisResourceCacheDb::isValid());
 
     KisResourceLocator::LocatorError r = m_locator->initialize(m_srcLocation);
     if (!m_locator->errorMessages().isEmpty()) qDebug() << m_locator->errorMessages();
 
     QVERIFY(r == KisResourceLocator::LocatorError::Ok);
     QVERIFY(QDir(m_dstLocation).exists());
 }
 
 
 void TestResourceModel::testRowCount()
 {
     QSqlQuery q;
     QVERIFY(q.prepare("SELECT count(*)\n"
                       "FROM   resources\n"
                       ",      resource_types\n"
                       "WHERE  resources.resource_type_id = resource_types.id\n"
                       "AND    resource_types.name = :resource_type"));
     q.bindValue(":resource_type", m_resourceType);
     QVERIFY(q.exec());
     q.first();
     int rowCount = q.value(0).toInt();
     QVERIFY(rowCount == 3);
     KisResourceModel resourceModel(m_resourceType);
     QCOMPARE(resourceModel.rowCount(), rowCount);
 }
 
 void TestResourceModel::testData()
 {
     KisResourceModel resourceModel(m_resourceType);
 
     QStringList resourceNames;
 
     for (int i = 0; i < resourceModel.rowCount(); ++i)  {
         QVariant v = resourceModel.data(resourceModel.index(i, KisResourceModel::Name), Qt::DisplayRole);
         resourceNames << v.toString();
     }
     QVERIFY(resourceNames.contains("test0.kpp"));
     QVERIFY(resourceNames.contains("test1.kpp"));
     QVERIFY(resourceNames.contains("test2.kpp"));
 }
 
 
 void TestResourceModel::testResourceForIndex()
 {
     KisResourceModel resourceModel(m_resourceType);
     KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(0, 0));
     QVERIFY(resource);
 }
 
 void TestResourceModel::testIndexFromResource()
 {
     KisResourceModel resourceModel(m_resourceType);
     KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(1, 0));
     QModelIndex idx = resourceModel.indexFromResource(resource);
     QVERIFY(idx.row() == 1);
     QVERIFY(idx.column() == 0);
 }
 
 void TestResourceModel::testRemoveResourceByIndex()
 {
     KisResourceModel resourceModel(m_resourceType);
     int resourceCount = resourceModel.rowCount();
     KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(1, 0));
     bool r = resourceModel.removeResource(resourceModel.index(1, 0));
     QVERIFY(r);
     QCOMPARE(resourceCount - 1, resourceModel.rowCount());
     QVERIFY(!resourceModel.indexFromResource(resource).isValid());
 
 }
 
 void TestResourceModel::testRemoveResource()
 {
     KisResourceModel resourceModel(m_resourceType);
     int resourceCount = resourceModel.rowCount();
     KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(1, 0));
     QVERIFY(resource);
 
     bool r = resourceModel.removeResource(resource);
     QVERIFY(r);
     QCOMPARE(resourceCount - 1, resourceModel.rowCount());
 
     QVERIFY(!resourceModel.indexFromResource(resource).isValid());
 }
 
 void TestResourceModel::testImportResourceFile()
 {
     KisResourceModel resourceModel(m_resourceType);
 
     QTemporaryFile f(QDir::tempPath() + "/testresourcemodel-testimportresourcefile-XXXXXX.kpp");
     f.open();
     f.write("0");
     f.close();
 
     int resourceCount = resourceModel.rowCount();
     bool r = resourceModel.importResourceFile(f.fileName());
     QVERIFY(r);
     QCOMPARE(resourceCount + 1, resourceModel.rowCount());
 }
 
 void TestResourceModel::testAddResource()
 {
     KisResourceModel resourceModel(m_resourceType);
     int resourceCount = resourceModel.rowCount();
     KoResourceSP resource(new DummyResource("dummy.kpp"));
     resource->setValid(true);
     bool r = resourceModel.addResource(resource);
     QVERIFY(r);
     QCOMPARE(resourceCount + 1, resourceModel.rowCount());
 }
 
 void TestResourceModel::testAddTemporaryResource()
 {
     KisResourceModel resourceModel(m_resourceType);
     int resourceCount = resourceModel.rowCount();
     KoResourceSP resource(new DummyResource("dummy.kpp"));
     resource->setValid(true);
     bool r = resourceModel.addResource(resource, "memory");
     QVERIFY(r);
     QCOMPARE(resourceCount + 1, resourceModel.rowCount());
 }
 
 void TestResourceModel::testUpdateResource()
 {
     int resourceId;
     {
         KisResourceModel resourceModel(m_resourceType);
         KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(0, 0));
         QVERIFY(resource);
         QVERIFY(resource.dynamicCast<DummyResource>()->something().isEmpty());
         resource.dynamicCast<DummyResource>()->setSomething("It's changed");
         resourceId = resource->resourceId();
         bool r = resourceModel.updateResource(resource);
         QVERIFY(r);
     }
 
     {
         // Check the resource itself
         KisResourceLocator::instance()->purge();
         KoResourceSP resource = KisResourceLocator::instance()->resourceForId(resourceId);
 
         QVERIFY(resource);
         QVERIFY(!resource.dynamicCast<DummyResource>()->something().isEmpty());
         QVERIFY(resource->resourceId() == resourceId);
 
         // Check the versions in the database
         QSqlQuery q;
         QVERIFY(q.prepare("SELECT count(*)\n"
                           "FROM   versioned_resources\n"
                           "WHERE  resource_id = :resource_id\n"));
         q.bindValue(":resource_id", resourceId);
         QVERIFY(q.exec());
         q.first();
         int rowCount = q.value(0).toInt();
         QCOMPARE(rowCount, 2);
     }
 }
 
 void TestResourceModel::testResourceForId()
 {
     KisResourceModel resourceModel(m_resourceType);
     KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(0, 0));
     QVERIFY(!resource.isNull());
     KoResourceSP resource2 = resourceModel.resourceForId(resource->resourceId());
     QVERIFY(!resource2.isNull());
     QCOMPARE(resource, resource2);
 }
 
 void TestResourceModel::testResourceForName()
 {
     KisResourceModel resourceModel(m_resourceType);
     KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(0, 0));
     QVERIFY(!resource.isNull());
     KoResourceSP resource2 = resourceModel.resourceForName(resource->name());
     QVERIFY(!resource2.isNull());
     QCOMPARE(resource, resource2);
 }
 
 void TestResourceModel::testResourceForFileName()
 {
     KisResourceModel resourceModel(m_resourceType);
     KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(0, 0));
     QVERIFY(!resource.isNull());
     KoResourceSP resource2 = resourceModel.resourceForFilename(resource->filename());
     QVERIFY(!resource2.isNull());
     QCOMPARE(resource, resource2);
 }
 
 void TestResourceModel::testResourceForMD5()
 {
     KisResourceModel resourceModel(m_resourceType);
     KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(0, 0));
     QVERIFY(!resource.isNull());
     KoResourceSP resource2 = resourceModel.resourceForMD5(resource->md5());
     QVERIFY(!resource2.isNull());
     QCOMPARE(resource->md5(), resource2->md5());
 }
 
+void TestResourceModel::testRenameResource()
+{
+    KisResourceModel resourceModel(m_resourceType);
+
+    KoResourceSP resource = resourceModel.resourceForIndex(resourceModel.index(0, 0));
+    QVERIFY(!resource.isNull());
+    const QString name = resource->name();
+    bool r = resourceModel.renameResource(resource, "A New Name");
+    QVERIFY(r);
+    QSqlQuery q;
+    if (!q.prepare("SELECT name\n"
+                   "FROM   resources\n"
+                   "WHERE  id = :resource_id\n")) {
+        qWarning() << "Could not prepare testRenameResource Query" << q.lastError();
+    }
+
+    q.bindValue(":resource_id", resource->resourceId());
+
+    if (!q.exec()) {
+        qWarning() << "Could not execute testRenameResource Query" << q.lastError();
+    }
+
+    q.first();
+    QString newName = q.value(0).toString();
+    QVERIFY(name != newName);
+    QCOMPARE("A New Name", newName);
+}
+
 void TestResourceModel::cleanupTestCase()
 {
     ResourceTestHelper::rmTestDb();
     ResourceTestHelper::cleanDstLocation(m_dstLocation);
 }
 
 
 QTEST_MAIN(TestResourceModel)
 
diff --git a/libs/resources/tests/TestResourceModel.h b/libs/resources/tests/TestResourceModel.h
index c047b5b8df..b899fab411 100644
--- a/libs/resources/tests/TestResourceModel.h
+++ b/libs/resources/tests/TestResourceModel.h
@@ -1,57 +1,58 @@
 /*
  * Copyright (c) 2018 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 TESTRESOURCEMODEL_H
 #define TESTRESOURCEMODEL_H
 
 #include <QObject>
 #include <QtSql>
 
 #include "KisResourceTypes.h"
 
 class KisResourceLocator;
 class TestResourceModel : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void testRowCount();
     void testData();
     void testResourceForIndex();
     void testIndexFromResource();
     void testRemoveResourceByIndex();
     void testRemoveResource();
     void testImportResourceFile();
     void testAddResource();
     void testAddTemporaryResource();
     void testUpdateResource();
     void testResourceForId();
     void testResourceForName();
     void testResourceForFileName();
     void testResourceForMD5();
+    void testRenameResource();
     void cleanupTestCase();
 private:
 
     QString m_srcLocation;
     QString m_dstLocation;
 
     KisResourceLocator *m_locator;
     const QString m_resourceType = ResourceType::PaintOpPresets;
 
 };
 
 #endif
diff --git a/libs/ui/widgets/kis_preset_chooser.cpp b/libs/ui/widgets/kis_preset_chooser.cpp
index 241087ab6c..1b36ce92fc 100644
--- a/libs/ui/widgets/kis_preset_chooser.cpp
+++ b/libs/ui/widgets/kis_preset_chooser.cpp
@@ -1,450 +1,459 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2009 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@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_preset_chooser.h"
 
 #include <QVBoxLayout>
 #include <QPainter>
 #include <QAbstractItemDelegate>
 #include <QStyleOptionViewItem>
 #include <QSortFilterProxyModel>
 #include <KisResourceModel.h>
 #include <QApplication>
 
 #include <kis_config.h>
 #include <klocalizedstring.h>
 #include <KisKineticScroller.h>
 
 #include <KoIcon.h>
 #include <KisResourceItemChooser.h>
 #include <KisResourceItemChooserSync.h>
 #include <KisResourceItemListView.h>
 #include <KisResourceModel.h>
 #include <KisResourceLocator.h>
 
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_preset.h>
 #include "KisResourceServerProvider.h"
 #include "kis_global.h"
 #include "kis_slider_spin_box.h"
 #include "kis_config_notifier.h"
 #include <kis_icon.h>
 
 /// The resource item delegate for rendering the resource preview
 class KisPresetDelegate : public QAbstractItemDelegate
 {
 public:
     KisPresetDelegate(QObject * parent = 0) : QAbstractItemDelegate(parent), m_showText(false), m_useDirtyPresets(false) {}
     ~KisPresetDelegate() override {}
     /// reimplemented
     void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const override;
     /// reimplemented
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex &) const override {
         return option.decorationSize;
     }
 
     void setShowText(bool showText) {
         m_showText = showText;
     }
 
     void setUseDirtyPresets(bool value) {
         m_useDirtyPresets = value;
     }
 
 private:
     bool m_showText;
     bool m_useDirtyPresets;
 };
 
 void KisPresetDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     painter->save();
     painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
 
     if (!index.isValid()) {
         qDebug() << "KisPresetDelegate::paint: index is invalid";
         painter->restore();
         return;
     }
 
     bool dirty = index.data(Qt::UserRole + KisResourceModel::Dirty).toBool();
 
     QImage preview = index.data(Qt::UserRole + KisResourceModel::Image).value<QImage>();
 
     if (preview.isNull()) {
         qDebug() << "KisPresetDelegate::paint:  Preview is null";
         painter->restore();
         return;
     }
 
     QMap<QString, QVariant> metaData = index.data(Qt::UserRole + KisResourceModel::MetaData).value<QMap<QString, QVariant>>();
 
     QRect paintRect = option.rect.adjusted(1, 1, -1, -1);
     if (!m_showText) {
         painter->drawImage(paintRect.x(), paintRect.y(),
                            preview.scaled(paintRect.size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     }
     else {
         QSize pixSize(paintRect.height(), paintRect.height());
         painter->drawImage(paintRect.x(), paintRect.y(),
                            preview.scaled(pixSize, Qt::KeepAspectRatio, Qt::SmoothTransformation));
 
         // Put an asterisk after the preset if it is dirty. This will help in case the pixmap icon is too small
 
         QString dirtyPresetIndicator = QString("");
         if (m_useDirtyPresets && dirty) {
             dirtyPresetIndicator = QString("*");
         }
 
 //        qreal brushSize = metaData["paintopSize"].toReal();
 //        QString brushSizeText;
 
 //        // Disable displayed decimal precision beyond a certain brush size
 //        if (brushSize < 100) {
 //            brushSizeText = QString::number(brushSize, 'g', 3);
 //        } else {
 //            brushSizeText = QString::number(brushSize, 'f', 0);
 //        }
 
 //        painter->drawText(pixSize.width() + 10, option.rect.y() + option.rect.height() - 10, brushSizeText); // brush size
 
         QString presetDisplayName = index.data(Qt::UserRole + KisResourceModel::Name).toString().replace("_", " "); // don't need underscores that might be part of the file name
         painter->drawText(pixSize.width() + 40, option.rect.y() + option.rect.height() - 10, presetDisplayName.append(dirtyPresetIndicator));
 
     }
 
     if (m_useDirtyPresets && dirty) {
         const QIcon icon = KisIconUtils::loadIcon(koIconName("dirty-preset"));
         QPixmap pixmap = icon.pixmap(QSize(15,15));
         painter->drawPixmap(paintRect.x() + 3, paintRect.y() + 3, pixmap);
     }
 
 //    if (!preset->settings() || !preset->settings()->isValid()) {
 //        const QIcon icon = KisIconUtils::loadIcon("broken-preset");
 //        icon.paint(painter, QRect(paintRect.x() + paintRect.height() - 25, paintRect.y() + paintRect.height() - 25, 25, 25));
 //    }
 
     if (option.state & QStyle::State_Selected) {
         painter->setCompositionMode(QPainter::CompositionMode_HardLight);
         painter->setOpacity(1.0);
         painter->fillRect(option.rect, option.palette.highlight());
 
         // highlight is not strong enough to pick out preset. draw border around it.
         painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
         painter->setPen(QPen(option.palette.highlight(), 4, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
         QRect selectedBorder = option.rect.adjusted(2 , 2, -2, -2); // constrict the rectangle so it doesn't bleed into other presets
         painter->drawRect(selectedBorder);
     }
 
     painter->restore();
 
 }
 
 class KisPresetChooser::PaintOpFilterModel : public QSortFilterProxyModel, public KisAbstractResourceModel
 {
     Q_OBJECT
 public:
 
     PaintOpFilterModel(QObject *parent = 0)
         : QSortFilterProxyModel(parent)
     {
     }
 
     ~PaintOpFilterModel() override
     {
     }
 
     void setPaintOpId(const QString &id)
     {
         m_id = id;
     }
 
     QString currentPaintOpId() const
     {
         return m_id;
     }
     // KisAbstractResourceModel interface
 public:
     KoResourceSP resourceForIndex(QModelIndex index) const override
     {
         KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
         if (source) {
             return source->resourceForIndex(mapToSource(index));
         }
         return 0;
     }
 
     QModelIndex indexFromResource(KoResourceSP resource) const override
     {
         KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
         if (source) {
             return mapFromSource(source->indexFromResource(resource));
         }
         return QModelIndex();
     }
 
     bool removeResource(const QModelIndex &index) override
     {
         KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
         if (source) {
             return source->removeResource(mapToSource(index));
         }
         return false;
     }
 
     bool importResourceFile(const QString &filename) override
     {
         KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
         if (source) {
             return source->importResourceFile(filename);
         }
         return false;
     }
 
     bool addResource(KoResourceSP resource, const QString &storageId = QString()) override
     {
         KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
         if (source) {
             return source->addResource(resource, storageId);
         }
         return false;
     }
 
     bool updateResource(KoResourceSP resource) override
     {
         KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
         if (source) {
             return source->updateResource(resource);
         }
         return false;
     }
 
+    bool renameResource(KoResourceSP resource, const QString &name) override
+    {
+        KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
+        if (source) {
+            return source->renameResource(resource, name);
+        }
+        return false;
+    }
+
     bool removeResource(KoResourceSP resource) override
     {
         KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
         if (source) {
             return source->removeResource(resource);
         }
         return false;
     }
 
     bool setResourceMetaData(KoResourceSP resource, QMap<QString, QVariant> metadata) override
     {
         KisAbstractResourceModel *source = dynamic_cast<KisAbstractResourceModel*>(sourceModel());
         if (source) {
             return source->setResourceMetaData(resource, metadata);
         }
         return false;
     }
 
 
     // QSortFilterProxyModel interface
 protected:
 
     QVariant data(const QModelIndex &index, int role) const override
     {
         return sourceModel()->data(mapToSource(index), role);
     }
 
     bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override
     {
         if (m_id.isEmpty()) return true;
 
         QModelIndex idx = sourceModel()->index(source_row, 0, source_parent);
         QMap<QString, QVariant> metadata = sourceModel()->data(idx, Qt::UserRole + KisResourceModel::MetaData).toMap();
         if (metadata.contains("paintopid")) {
             return (metadata["paintopid"].toString() == m_id);
         }
 
         return false;
     }
 
     bool filterAcceptsColumn(int /*source_column*/, const QModelIndex &/*source_parent*/) const override
     {
         return true;
     }
 
     bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const override
     {
         QString nameLeft = sourceModel()->data(source_left, Qt::UserRole + KisResourceModel::Name).toString();
         QString nameRight = sourceModel()->data(source_right, Qt::UserRole + KisResourceModel::Name).toString();
         return nameLeft < nameRight;
     }
 
 private:
 
     QString m_id;
 };
 
 KisPresetChooser::KisPresetChooser(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
     QVBoxLayout * layout = new QVBoxLayout(this);
     layout->setMargin(0);
 
     m_paintOpFilterModel = new PaintOpFilterModel();
 
     m_chooser = new KisResourceItemChooser(ResourceType::PaintOpPresets, false, this, m_paintOpFilterModel);
     m_chooser->setObjectName("ResourceChooser");
     m_chooser->setRowHeight(50);
     m_delegate = new KisPresetDelegate(this);
     m_chooser->setItemDelegate(m_delegate);
     m_chooser->setSynced(true);
     layout->addWidget(m_chooser);
 
     {
         QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(this->itemChooser()->itemView());
         if (scroller) {
             connect(scroller, SIGNAL(stateChanged(QScroller::State)),
                     this, SLOT(slotScrollerStateChanged(QScroller::State)));
         }
     }
     connect(m_chooser, SIGNAL(resourceSelected(KoResourceSP )),
             this, SIGNAL(resourceSelected(KoResourceSP )));
     connect(m_chooser, SIGNAL(resourceClicked(KoResourceSP )),
             this, SIGNAL(resourceClicked(KoResourceSP )));
 
     m_mode = THUMBNAIL;
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(notifyConfigChanged()));
 
 
     notifyConfigChanged();
 }
 
 KisPresetChooser::~KisPresetChooser()
 {
 }
 
 void KisPresetChooser::showButtons(bool show)
 {
     m_chooser->showButtons(show);
 }
 
 void KisPresetChooser::setViewMode(KisPresetChooser::ViewMode mode)
 {
     m_mode = mode;
     updateViewSettings();
 }
 
 void KisPresetChooser::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     updateViewSettings();
 }
 
 void KisPresetChooser::notifyConfigChanged()
 {
     KisConfig cfg(true);
     m_delegate->setUseDirtyPresets(cfg.useDirtyPresets());
     setIconSize(cfg.presetIconSize());
 
     updateViewSettings();
 }
 
 void KisPresetChooser::updateViewSettings()
 {
     if (m_mode == THUMBNAIL) {
         m_chooser->setSynced(true);
         m_delegate->setShowText(false);
         m_chooser->itemView()->setViewMode(QListView::IconMode);
         m_chooser->itemView()->setFlow(QListView::LeftToRight);
     }
     else if (m_mode == DETAIL) {
         m_chooser->setSynced(false);
         m_chooser->itemView()->setViewMode(QListView::ListMode);
         m_chooser->itemView()->setFlow(QListView::TopToBottom);
         m_chooser->setColumnWidth(m_chooser->width());
 
         KisResourceItemChooserSync* chooserSync = KisResourceItemChooserSync::instance();
         m_chooser->setRowHeight(chooserSync->baseLength());
         m_delegate->setShowText(true);
     }
     else if (m_mode == STRIP) {
         m_chooser->setSynced(false);
         m_chooser->itemView()->setViewMode(QListView::ListMode);
         m_chooser->itemView()->setFlow(QListView::LeftToRight);
         // An offset of 7 keeps the cell exactly square, TODO: use constants, not hardcoded numbers
         m_chooser->setColumnWidth(m_chooser->viewSize().height() - 7);
         m_delegate->setShowText(false);
     }
 }
 
 void KisPresetChooser::setCurrentResource(KoResourceSP resource)
 {
     m_chooser->setCurrentResource(resource);
 }
 
 KoResourceSP KisPresetChooser::currentResource() const
 {
     return m_chooser->currentResource();
 }
 
 void KisPresetChooser::showTaggingBar(bool show)
 {
     m_chooser->showTaggingBar(show);
 }
 
 KisResourceItemChooser *KisPresetChooser::itemChooser()
 {
     return m_chooser;
 }
 
 
 void KisPresetChooser::setPresetFilter(const QString& paintOpId)
 {
     if (m_paintOpFilterModel && m_paintOpFilterModel->currentPaintOpId() != paintOpId) {
         m_paintOpFilterModel->setPaintOpId(paintOpId);
         updateViewSettings();
     }
 }
 
 void KisPresetChooser::setIconSize(int newSize)
 {
     KisResourceItemChooserSync* chooserSync = KisResourceItemChooserSync::instance();
     chooserSync->setBaseLength(newSize);
     updateViewSettings();
 }
 
 int KisPresetChooser::iconSize()
 {
     KisResourceItemChooserSync* chooserSync = KisResourceItemChooserSync::instance();
     return chooserSync->baseLength();
 }
 
 
 
 void KisPresetChooser::saveIconSize()
 {
     // save icon size
     KisConfig cfg(false);
     cfg.setPresetIconSize(iconSize());
 }
 
 void KisPresetChooser::slotScrollerStateChanged(QScroller::State state)
 {
     KisKineticScroller::updateCursor(this, state);
 }
 
 #include "kis_preset_chooser.moc"