diff --git a/libs/brush/CMakeLists.txt b/libs/brush/CMakeLists.txt
index 5c17b7b80f..a6f851515d 100644
--- a/libs/brush/CMakeLists.txt
+++ b/libs/brush/CMakeLists.txt
@@ -1,50 +1,51 @@
 add_subdirectory( tests )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
 )
 
 set(kritalibbrush_LIB_SRCS
     kis_predefined_brush_factory.cpp
     kis_auto_brush.cpp
     kis_boundary.cc
     kis_brush.cpp
     kis_scaling_size_brush.cpp
     kis_brush_registry.cpp
     KisBrushServerProvider.cpp
     kis_gbr_brush.cpp
     kis_abr_brush.cpp
     kis_abr_brush_collection.cpp
     kis_imagepipe_brush.cpp
     kis_pipebrush_parasite.cpp
     kis_png_brush.cpp
     kis_svg_brush.cpp
     kis_qimage_pyramid.cpp
     KisSharedQImagePyramid.cpp
     kis_text_brush.cpp
     kis_auto_brush_factory.cpp
     kis_text_brush_factory.cpp
+    KisAbrStorage.cpp
 )
 
 add_library(kritalibbrush SHARED ${kritalibbrush_LIB_SRCS} )
 generate_export_header(kritalibbrush BASE_NAME kritabrush EXPORT_MACRO_NAME BRUSH_EXPORT)
 
 if (WIN32)
     target_link_libraries(kritalibbrush kritaimage Qt5::Svg ${WIN32_PLATFORM_NET_LIBS})
 else ()
     target_link_libraries(kritalibbrush kritaimage Qt5::Svg)
 endif ()
 
 
 if(HAVE_VC)
   include_directories(SYSTEM ${Vc_INCLUDE_DIR})
   target_link_libraries(kritalibbrush  ${Vc_LIBRARIES})
 #  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Vc_DEFINITIONS}")
 endif()
 
 set_target_properties(kritalibbrush PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 
 install(TARGETS kritalibbrush  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
diff --git a/libs/resources/KisAbrStorage.cpp b/libs/brush/KisAbrStorage.cpp
similarity index 89%
rename from libs/resources/KisAbrStorage.cpp
rename to libs/brush/KisAbrStorage.cpp
index 6063c5794d..0ec29707b0 100644
--- a/libs/resources/KisAbrStorage.cpp
+++ b/libs/brush/KisAbrStorage.cpp
@@ -1,87 +1,95 @@
 /*
  * 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 "KisAbrStorage.h"
 #include "KisResourceStorage.h"
 
+struct KisAbrStorageStaticRegistrar {
+    KisAbrStorageStaticRegistrar() {
+        KisStoragePluginRegistry::instance()->addStoragePluginFactory(KisResourceStorage::StorageType::AdobeBrushLibrary, new KisStoragePluginFactory<KisAbrStorage>());
+    }
+};
+static KisAbrStorageStaticRegistrar s_registrar;
+
+
 class AbrTagIterator : public KisResourceStorage::TagIterator
 {
 public:
     AbrTagIterator(const QString &location, const QString &resourceType)
         : m_location(location)
         , m_resourceType(resourceType)
     {}
 
     bool hasNext() const override {return false; }
     void next() const override {}
 
     QString url() const override { return QString(); }
     QString name() const override { return QString(); }
     QString comment() const override {return QString(); }
     KisTagSP tag() const override { return 0; }
 private:
 
     QString m_location;
     QString m_resourceType;
 };
 
 class AbrIterator : public KisResourceStorage::ResourceIterator
 {
 public:
     bool hasNext() const override {return false; }
     void next() const override {}
 
     QString url() const override { return QString(); }
     QString type() const override { return QString(); }
     QDateTime lastModified() const override { return QDateTime(); }
     /// This only loads the resource when called
     KoResourceSP resource() const override { return 0; }
 };
 
 KisAbrStorage::KisAbrStorage(const QString &location)
     : KisStoragePlugin(location)
 {
 
 }
 
 KisAbrStorage::~KisAbrStorage()
 {
 
 }
 
 KisResourceStorage::ResourceItem KisAbrStorage::resourceItem(const QString &/*url*/)
 {
     return KisResourceStorage::ResourceItem();
 }
 
 
 KoResourceSP KisAbrStorage::resource(const QString &/*url*/)
 {
     return 0;
 }
 
 QSharedPointer<KisResourceStorage::ResourceIterator> KisAbrStorage::resources(const QString &/*resourceType*/)
 {
     return QSharedPointer<KisResourceStorage::ResourceIterator>(new AbrIterator);
 }
 
 QSharedPointer<KisResourceStorage::TagIterator> KisAbrStorage::tags(const QString &resourceType)
 {
     return QSharedPointer<KisResourceStorage::TagIterator>(new AbrTagIterator(location(), resourceType));
 }
diff --git a/libs/resources/KisAbrStorage.h b/libs/brush/KisAbrStorage.h
similarity index 93%
rename from libs/resources/KisAbrStorage.h
rename to libs/brush/KisAbrStorage.h
index 831c87248e..3a22bde23d 100644
--- a/libs/resources/KisAbrStorage.h
+++ b/libs/brush/KisAbrStorage.h
@@ -1,39 +1,42 @@
 /*
  * 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 KISABRSTORAGE_H
 #define KISABRSTORAGE_H
 
 #include <KisStoragePlugin.h>
 
-class KisAbrStorage : public KisStoragePlugin
+#include <kritabrush_export.h>
+
+
+class BRUSH_EXPORT KisAbrStorage : public KisStoragePlugin
 {
 public:
     KisAbrStorage(const QString &location);
     virtual ~KisAbrStorage();
 
     KisResourceStorage::ResourceItem resourceItem(const QString &url) override;
 
     KoResourceSP resource(const QString &url) override;
     QSharedPointer<KisResourceStorage::ResourceIterator> resources(const QString &resourceType) override;
     QSharedPointer<KisResourceStorage::TagIterator> tags(const QString &resourceType) override;
 
 };
 
 #endif // KISABRSTORAGE_H
diff --git a/libs/resources/CMakeLists.txt b/libs/resources/CMakeLists.txt
index 26d55eb03e..9a0a5272ae 100644
--- a/libs/resources/CMakeLists.txt
+++ b/libs/resources/CMakeLists.txt
@@ -1,67 +1,66 @@
 include_directories(${QUAZIP_INCLUDE_DIRS})
 
 add_subdirectory(tests)
 
 set(kritaresources_LIB_SRCS
     KisResourceCacheDb.cpp
     KisResourceLoader.cpp
     KisResourceLoaderRegistry.cpp
     KisResourceLocator.cpp
     KisResourceStorage.cpp
     KisResourceModel.cpp
     KisResourceGridProxyModel.cpp
     KisTagFilterResourceProxyModel.cpp
     KisResourceModelProvider.cpp
     KisResourceTypeModel.cpp
     KisStorageModel.cpp
     KisResourceIterator.cpp
 
     KisStoragePlugin.cpp
-    KisAbrStorage.cpp
     KisAslStorage.cpp
     KisBundleStorage.cpp
     KisFolderStorage.cpp
     KisMemoryStorage.cpp
 
     KisTag.cpp
     KisTagModel.cpp
 
     KoResource.cpp
     KoResourceBundle.cpp
     KoResourceBundleManifest.cpp
     KoMD5Generator.cpp
     KoHashGeneratorProvider.cpp
     KoResourcePaths.cpp
 
     kconfigini.cpp
     kconfigdata.cpp
     kconfigbackend.cpp
 )
 
 qt5_add_resources(kritaresources_LIB_SRCS sql.qrc)
 
 add_library(kritaresources SHARED ${kritaresources_LIB_SRCS})
 
 generate_export_header(kritaresources BASE_NAME kritaresources)
 
 target_link_libraries(kritaresources
     PUBLIC
         Qt5::Core
         Qt5::Widgets
     PRIVATE
         Qt5::Sql
         kritaversion
         kritaglobal
         kritaplugin
         kritastore
         KF5::ConfigCore
         KF5::CoreAddons
         KF5::I18n
         ${QUAZIP_LIBRARIES}
 )
 
 set_target_properties(kritaresources PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaresources ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
diff --git a/libs/resources/KisResourceStorage.cpp b/libs/resources/KisResourceStorage.cpp
index 5ff09169b8..d84c793dc3 100644
--- a/libs/resources/KisResourceStorage.cpp
+++ b/libs/resources/KisResourceStorage.cpp
@@ -1,161 +1,183 @@
 /*
  * 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 "KisResourceStorage.h"
 
 #include <QFileInfo>
 #include <QDebug>
 
 #include <quazip.h>
 
-#include "KisStoragePlugin.h"
 #include "KisFolderStorage.h"
 #include "KisBundleStorage.h"
-#include "KisAbrStorage.h"
 #include "KisAslStorage.h"
 #include "KisMemoryStorage.h"
 
 const QString KisResourceStorage::s_meta_generator("meta:generator");
 const QString KisResourceStorage::s_meta_author("dc:author");
 const QString KisResourceStorage::s_meta_title("dc:title");
 const QString KisResourceStorage::s_meta_description("dc:description");
 const QString KisResourceStorage::s_meta_initial_creator("meta:initial-creator");
 const QString KisResourceStorage::s_meta_creator("cd:creator");
 const QString KisResourceStorage::s_meta_creation_date("meta:creation-data");
 const QString KisResourceStorage::s_meta_dc_date("meta:dc-date");
 const QString KisResourceStorage::s_meta_user_defined("meta:meta-userdefined");
 const QString KisResourceStorage::s_meta_name("meta:name");
 const QString KisResourceStorage::s_meta_value("meta:value");
 const QString KisResourceStorage::s_meta_version("meta:bundle-version");
 
+Q_GLOBAL_STATIC(KisStoragePluginRegistry, s_instance);
 
+KisStoragePluginRegistry::KisStoragePluginRegistry()
+{
+    m_storageFactoryMap[KisResourceStorage::StorageType::Folder] = new KisStoragePluginFactory<KisFolderStorage>();
+    m_storageFactoryMap[KisResourceStorage::StorageType::Memory] = new KisStoragePluginFactory<KisMemoryStorage>();
+    m_storageFactoryMap[KisResourceStorage::StorageType::Bundle] = new KisStoragePluginFactory<KisBundleStorage>();
+    m_storageFactoryMap[KisResourceStorage::StorageType::AdobeStyleLibrary] = new KisStoragePluginFactory<KisAslStorage>();
+}
+
+void KisStoragePluginRegistry::addStoragePluginFactory(KisResourceStorage::StorageType storageType, KisStoragePluginFactoryBase *factory)
+{
+    m_storageFactoryMap[storageType] = factory;
+}
+
+KisStoragePluginRegistry *KisStoragePluginRegistry::instance()
+{
+    return s_instance;
+}
 
 class KisResourceStorage::Private {
 public:
     QString name;
     QString location;
     bool valid {false};
     KisResourceStorage::StorageType storageType {KisResourceStorage::StorageType::Unknown};
     QSharedPointer<KisStoragePlugin> storagePlugin;
 };
 
-
 KisResourceStorage::KisResourceStorage(const QString &location)
     : d(new Private())
 {
+    Q_ASSERT(KisStoragePluginRegistry::instance()->m_storageFactoryMap.contains(StorageType::Folder));
+    Q_ASSERT(KisStoragePluginRegistry::instance()->m_storageFactoryMap.contains(StorageType::Bundle));
+    Q_ASSERT(KisStoragePluginRegistry::instance()->m_storageFactoryMap.contains(StorageType::Memory));
+    Q_ASSERT(KisStoragePluginRegistry::instance()->m_storageFactoryMap.contains(StorageType::AdobeBrushLibrary));
+    Q_ASSERT(KisStoragePluginRegistry::instance()->m_storageFactoryMap.contains(StorageType::AdobeStyleLibrary));
+
     d->location = location;
     d->name = QFileInfo(d->location).fileName();
     QFileInfo fi(d->location);
     if (fi.isDir()) {
-        d->storagePlugin.reset(new KisFolderStorage(location));
+        d->storagePlugin.reset(KisStoragePluginRegistry::instance()->m_storageFactoryMap[StorageType::Folder]->create(location));
         d->storageType = StorageType::Folder;
         d->valid = fi.isWritable();
     }
     else if (d->location.endsWith(".bundle")) {
-            d->storagePlugin.reset(new KisBundleStorage(location));
+            d->storagePlugin.reset(KisStoragePluginRegistry::instance()->m_storageFactoryMap[StorageType::Bundle]->create(location));
             d->storageType = StorageType::Bundle;
             // XXX: should we also check whether there's a valid metadata entry? Or is this enough?
             d->valid = (fi.isReadable() && QuaZip(d->location).open(QuaZip::mdUnzip));
     } else if (d->location.endsWith(".abr")) {
-            d->storagePlugin.reset(new KisAbrStorage(location));
+            d->storagePlugin.reset(KisStoragePluginRegistry::instance()->m_storageFactoryMap[StorageType::AdobeBrushLibrary]->create(location));
             d->storageType = StorageType::AdobeBrushLibrary;
             d->valid = fi.isReadable();
     } else if (d->location.endsWith(".asl")) {
-            d->storagePlugin.reset(new KisAslStorage(location));
+            d->storagePlugin.reset(KisStoragePluginRegistry::instance()->m_storageFactoryMap[StorageType::AdobeStyleLibrary]->create(location));
             d->storageType = StorageType::AdobeStyleLibrary;
             d->valid = fi.isReadable();
     }
     else if (!d->location.isEmpty()) {
-        d->storagePlugin.reset(new KisMemoryStorage);
+        d->storagePlugin.reset(KisStoragePluginRegistry::instance()->m_storageFactoryMap[StorageType::Memory]->create(location));
         d->name = location;
         d->storageType = StorageType::Memory;
         d->valid = true;
     }
 }
 
 KisResourceStorage::~KisResourceStorage()
 {
 }
 
 QString KisResourceStorage::name() const
 {
     return d->name;
 }
 
 QString KisResourceStorage::location() const
 {
     return d->location;
 }
 
 KisResourceStorage::StorageType KisResourceStorage::type() const
 {
     return d->storageType;
 }
 
 QDateTime KisResourceStorage::timestamp() const
 {
     if (d->storageType == StorageType::Memory) return QDateTime();
 
     return QFileInfo(d->location).lastModified();
 }
 
 KisResourceStorage::ResourceItem KisResourceStorage::resourceItem(const QString &url)
 {
     return d->storagePlugin->resourceItem(url);
 }
 
 KoResourceSP KisResourceStorage::resource(const QString &url)
 {
     return d->storagePlugin->resource(url);
 }
 
 QSharedPointer<KisResourceStorage::ResourceIterator> KisResourceStorage::resources(const QString &resourceType) const
 {
     return d->storagePlugin->resources(resourceType);
 }
 
 QSharedPointer<KisResourceStorage::TagIterator> KisResourceStorage::tags(const QString &resourceType) const
 {
     return d->storagePlugin->tags(resourceType);
 }
 
 bool KisResourceStorage::addTag(const QString &resourceType, KisTagSP tag)
 {
     return d->storagePlugin->addTag(resourceType, tag);
 }
 
 bool KisResourceStorage::addResource(const QString &resourceType, KoResourceSP resource)
 {
     return d->storagePlugin->addResource(resourceType, resource);
 }
 
 bool KisResourceStorage::valid() const
 {
     return d->valid;
 }
 
 QStringList KisResourceStorage::metaDataKeys() const
 {
     return d->storagePlugin->metaDataKeys();
 }
 
 QVariant KisResourceStorage::metaData(const QString &key) const
 {
     return d->storagePlugin->metaData(key);
 }
+
diff --git a/libs/resources/KisResourceStorage.h b/libs/resources/KisResourceStorage.h
index 665947574b..8e7c1dc30a 100644
--- a/libs/resources/KisResourceStorage.h
+++ b/libs/resources/KisResourceStorage.h
@@ -1,175 +1,204 @@
 /*
  * 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 KISRESOURCESTORAGE_H
 #define KISRESOURCESTORAGE_H
 
 #include <QSharedPointer>
 #include <QScopedPointer>
 #include <QString>
 #include <QDateTime>
+#include <QMap>
 
 #include <KoResource.h>
-
 #include <KisTag.h>
 
 #include <kritaresources_export.h>
 
+class KisStoragePlugin;
+
+class KRITARESOURCES_EXPORT KisStoragePluginFactoryBase
+{
+public:
+    virtual ~KisStoragePluginFactoryBase(){}
+    virtual KisStoragePlugin *create(const QString &/*location*/) { return 0; }
+};
+
+template<typename T>
+class KRITARESOURCES_EXPORT KisStoragePluginFactory : public KisStoragePluginFactoryBase
+{
+public:
+    KisStoragePlugin *create(const QString &location) override {
+        return new T(location);
+    }
+};
+
 
 /**
  * The KisResourceStorage class is the base class for
  * places where resources can be stored. Examples are
  * folders, bundles or Adobe resource libraries like
  * ABR files.
  */
 class KRITARESOURCES_EXPORT KisResourceStorage
 {
 public:
 
     /// A resource item is simply an entry in the storage,
     struct ResourceItem {
 
         virtual ~ResourceItem() {}
         QString url;
         QString folder;
         QString resourceType;
         QDateTime lastModified;
     };
 
     class TagIterator
     {
     public:
         virtual ~TagIterator() {}
         virtual bool hasNext() const = 0;
         /// The iterator is only valid if next() has been called at least once.
         virtual void next() const = 0;
 
         /// The untranslated name of the tag, to be used for making connections to resources
         virtual QString url() const = 0;
         /// The translated name of the tag, to be shown in the GUI
         virtual QString name() const = 0;
         /// An extra, optional comment for the tag
         virtual QString comment() const = 0;
 
         /// A tag object on which we can set properties and which we can save
         virtual KisTagSP tag() const = 0;
     };
 
     class ResourceIterator
     {
     public:
 
         virtual ~ResourceIterator() {}
 
         virtual bool hasNext() const = 0;
         /// The iterator is only valid if next() has been called at least once.
         virtual void next() const = 0;
 
         virtual QString url() const = 0;
         virtual QString type() const = 0;
         virtual QDateTime lastModified() const = 0;
         /// This only loads the resource when called
         virtual KoResourceSP resource() const = 0;
     };
 
     enum class StorageType : int {
         Unknown = 1,
         Folder = 2,
         Bundle = 3,
         AdobeBrushLibrary = 4,
         AdobeStyleLibrary = 5,
         Memory = 6
     };
 
     static QString storageTypeToString(StorageType storageType) {
         switch (storageType) {
         case StorageType::Unknown:
             return "Unknown";
         case StorageType::Folder:
             return "Folder";
         case StorageType::Bundle:
             return "Bundle";
         case StorageType::AdobeBrushLibrary:
             return "Adobe Brush Library";
         case StorageType::AdobeStyleLibrary:
             return "Adobe Style Library";
         case StorageType::Memory:
             return "Memory";
         default:
             return "Invalid";
         }
     }
 
 
     KisResourceStorage(const QString &location);
     ~KisResourceStorage();
 
     QString name() const;
     QString location() const;
     bool valid() const;
     StorageType type() const;
     QDateTime timestamp() const;
 
     ResourceItem resourceItem(const QString &url);
     KoResourceSP resource(const QString &url);
     QSharedPointer<ResourceIterator> resources(const QString &resourceType) const;
     QSharedPointer<TagIterator> tags(const QString &resourceType) const;
 
     bool addTag(const QString &resourceType, KisTagSP tag);
     bool addResource(const QString &resourceType, KoResourceSP resource);
 
     static const QString s_meta_generator;
     static const QString s_meta_author;
     static const QString s_meta_title;
     static const QString s_meta_description;
     static const QString s_meta_initial_creator;
     static const QString s_meta_creator;
     static const QString s_meta_creation_date;
     static const QString s_meta_dc_date;
     static const QString s_meta_user_defined;
     static const QString s_meta_name;
     static const QString s_meta_value;
     static const QString s_meta_version;
 
     QStringList metaDataKeys() const;
     QVariant metaData(const QString &key) const;
 
-
-
 private:
+
     class Private;
     QScopedPointer<Private> d;
 };
 
 
 typedef QSharedPointer<KisResourceStorage> KisResourceStorageSP;
 
 inline QDebug operator<<(QDebug dbg, const KisResourceStorageSP storage)
 {
     dbg.nospace() << "[RESOURCESTORAGE] Name: " << storage->name()
                   << " Version: " << storage->location()
                   << " Valid: " << storage->valid()
                   << " Storage: " << KisResourceStorage::storageTypeToString(storage->type())
                   << " Timestamp: " << storage->timestamp();
 
     return dbg.space();
 }
 
+class KRITARESOURCES_EXPORT KisStoragePluginRegistry {
+public:
+    KisStoragePluginRegistry();
+    void addStoragePluginFactory(KisResourceStorage::StorageType storageType, KisStoragePluginFactoryBase *factory);
+    static KisStoragePluginRegistry *instance();
+private:
+    friend class KisResourceStorage;
+    QMap<KisResourceStorage::StorageType, KisStoragePluginFactoryBase*> m_storageFactoryMap;
+
+};
+
+
 
 #endif // KISRESOURCESTORAGE_H