KisResourceLocator Class Reference

#include <KisResourceLocator.h>

Inheritance diagram for KisResourceLocator:

Classes
class	Private
struct	ResourceStorage

Public Types
enum class	LocatorError {   Ok , LocationReadOnly , CannotCreateLocation , CannotInitializeDb ,   CannotSynchronizeDb }

Signals
void	beginExternalResourceImport (const QString &resourceType, int numResources)
	Emitted when the locator needs to add an embedded resource.
void	beginExternalResourceRemove (const QString &resourceType, const QVector< int > resourceIds)
	Emitted when the locator needs to add an embedded resource.
void	endExternalResourceImport (const QString &resourceType)
	Emitted when the locator finished importing the embedded resource.
void	endExternalResourceRemove (const QString &resourceType)
	Emitted when the locator finished importing the embedded resource.
void	progressMessage (const QString &)
void	resourceActiveStateChanged (const QString &resourceType, int resourceId)
	Emitted when a resource changes its active state.
void	storageAdded (const QString &location)
	Emitted whenever a storage is added.
void	storageRemoved (const QString &location)
	Emitted whenever a storage is removed.
void	storageResynchronized (const QString &storage, bool isBulkResynchronization)
void	storagesBulkSynchronizationFinished ()

Public Member Functions
bool	addStorage (const QString &storageLocation, KisResourceStorageSP storage)
	addStorage Adds a new resource storage to the database. The storage is will be marked as not pre-installed. If there is already a storage with the given location, it will first be removed.
QStringList	errorMessages () const
	errorMessages
QString	filePathForResource (KoResourceSP resource)
bool	hasStorage (const QString &storageLocation)
	hasStorage can be used to check whether the given storage already exists
LocatorError	initialize (const QString &installationResourcesLocation)
	initialize Setup the resource locator for use.
void	purge (const QString &storageLocation, const QVector< int > &removedTagIds)
	purge purges the local resource cache
void	purgeTag (const QString tagUrl, const QString resourceType)
bool	removeStorage (const QString &storageLocation)
	removeStorage removes the temporary storage from the database
QString	resourceLocationBase () const
	resourceLocationBase is the place where all resource storages (folder, bundles etc. are located. This is a writable place.
void	updateFontStorage ()
	This updates the "fontregistry" storage. Called when the font directories change;.
	~KisResourceLocator ()

Static Public Member Functions
static KisResourceLocator *	instance ()
static void	saveTags ()
	saveTags saves all tags to .tag files in the resource folder

Static Public Attributes
static const QString	resourceLocationKey {"ResourceDirectory"}

Private Types
enum class	InitializationStatus {   Unknown , Initialized , FirstRun , FirstUpdate ,   Updating }

Private Member Functions
bool	addResource (const QString &resourceType, const KoResourceSP resource, const QString &storageLocation=QString())
	addResource adds the given resource to the database and potentially a storage
bool	addResourceDeduplicateFileName (const QString &resourceType, const KoResourceSP resource, const QString &storageLocation)
	addResourceDeduplicateFileName imports the resource fith file name deduplication
bool	exportResource (KoResourceSP resource, QIODevice *device)
	exportResource
void	findStorages ()
LocatorError	firstTimeInstallation (InitializationStatus initializationStatus, const QString &installationResourcesLocation)
KisResourceStorageSP	folderStorage () const
KisResourceStorageSP	fontStorage () const
ResourceStorage	getResourceStorage (int resourceId) const
KoResourceSP	importResource (const QString &resourceType, const QString &fileName, QIODevice *device, const bool allowOverwrite, const QString &storageLocation=QString())
	importResource
KoResourceSP	importResourceDeduplicateFileName (const QString &resourceType, const QString &proposedFileName, QIODevice *device, const QString &storageLocation=QString())
	importResourceDeduplicateFileName imports the resource fith file name deduplication
KoResourceSP	importResourceFromFile (const QString &resourceType, const QString &fileName, const bool allowOverwrite, const QString &storageLocation=QString())
	importResourceFromFile
bool	importWillOverwriteResource (const QString &resourceType, const QString &fileName, const QString &storageLocation=QString()) const
	return whether importing will overwrite some existing resource
	KisResourceLocator (const KisResourceLocator &)
	KisResourceLocator (QObject *parent)
void	loadRequiredResources (KoResourceSP resource)
QString	makeStorageLocationAbsolute (QString storageLocation) const
QString	makeStorageLocationRelative (QString location) const
KisResourceStorageSP	memoryStorage () const
QMap< QString, QVariant >	metaDataForResource (int id) const
	metaDataForResource
QMap< QString, QVariant >	metaDataForStorage (const QString &storageLocation) const
	metaDataForStorage
KisResourceLocator	operator= (const KisResourceLocator &)
bool	reloadResource (const QString &resourceType, const KoResourceSP resource)
	Reloads the resource from its persistent storage.
KoResourceSP	resource (QString storageLocation, const QString &resourceType, const QString &filename)
	resource finds a physical resource in one of the storages
bool	resourceCached (QString storageLocation, const QString &resourceType, const QString &filename) const
KoResourceSP	resourceForId (int resourceId)
	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.
bool	setMetaDataForResource (int id, QMap< QString, QVariant > map) const
	setMetaDataForResource
void	setMetaDataForStorage (const QString &storageLocation, QMap< QString, QVariant > map) const
	setMetaDataForStorage
bool	setResourceActive (int resourceId, bool active)
	setResourceActive
KisResourceStorageSP	storageByLocation (const QString &location) const
QList< KisResourceStorageSP >	storages () const
bool	synchronizeDb ()
KisTagSP	tagForUrl (const QString &tagUrl, const QString resourceType)
	tagForUrl create a tag from the database
bool	updateResource (const QString &resourceType, const KoResourceSP resource)
	updateResource

Static Private Member Functions
static KisTagSP	tagForUrlNoCache (const QString &tagUrl, const QString resourceType)
	tagForUrlNoCache create a tag from the database, don't use cache

Private Attributes
QScopedPointer< Private >	d

Friends
class	KisAllResourcesModel
class	KisAllTagResourceModel
class	KisAllTagsModel
class	KisBrushTypeMetaDataFixup
class	KisMyPaintPaintOpPreset
class	KisResourceCacheDb
class	KisResourceQueryMapper
class	KisResourceThumbnailCache
class	KisResourceUserOperations
class	KisStorageFilterProxyModel
class	KisStorageModel
class	KisTagResourceModel
class	Resource
class	TestResourceLocator
class	TestResourceModel

Detailed Description

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.

Definition at line 32 of file KisResourceLocator.h.

Member Enumeration Documentation

InitializationStatus

enum class KisResourceLocator::InitializationStatus

strongprivate

Enumerator
Unknown
Initialized
FirstRun
FirstUpdate
Updating

Definition at line 360 of file KisResourceLocator.h.

                                    {
        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

enum class KisResourceLocator::LocatorError

strong

Enumerator
Ok
LocationReadOnly
CannotCreateLocation
CannotInitializeDb
CannotSynchronizeDb

Definition at line 47 of file KisResourceLocator.h.

                            {
        Ok,
        LocationReadOnly,
        CannotCreateLocation,
        CannotInitializeDb,
        CannotSynchronizeDb
    };

Constructor & Destructor Documentation

~KisResourceLocator()

KisResourceLocator::~KisResourceLocator

(

)

Definition at line 90 of file KisResourceLocator.cpp.

{
}

KisResourceLocator() [1/2]

KisResourceLocator::KisResourceLocator ( QObject * parent )

private

Definition at line 73 of file KisResourceLocator.cpp.

    : QObject(parent)
    , d(new Private())
{
}

KisResourceLocator() [2/2]

KisResourceLocator::KisResourceLocator ( const KisResourceLocator & )

private

Member Function Documentation

addResource()

bool KisResourceLocator::addResource ( const QString & resourceType, const KoResourceSP resource, const QString & storageLocation = QString() )

private

addResource adds the given resource to the database and potentially a storage

Parameters

resourceType	the type of the resource
resource	the actual resource object
storageLocation	the storage where the resource will be saved. By default this is the default folder storage.

Returns

true if successful

And to the database.

The metadata will be set by KisResourceCacheDb, which is not very consistent with KisResourceLocator::updateResource(), but works :)

Definition at line 677 of file KisResourceLocator.cpp.

{
    if (!resource || !resource->valid()) return false;
 
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(storageLocation));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, false);
 
    //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()) {
        resource->setFilename(resource->name().split(" ").join("_") + resource->defaultFileExtension());
    }
 
    if (resource->version() != 0) { // Can happen with cloned resources
        resource->setVersion(0);
    }
 
    // Save the resource to the storage storage
    if (!storage->addResource(resource)) {
        qWarning() << "Could not add resource" << resource->filename() << "to the storage" << storageLocation;
        return false;
    }
 
    resource->setStorageLocation(storageLocation);
    resource->setMD5Sum(storage->resourceMd5(resourceType + "/" + resource->filename()));
    resource->setDirty(false);
    loadRequiredResources(resource);
 
    d->resourceCache[QPair<QString, QString>(storageLocation, resourceType + "/" + resource->filename())] = resource;
 
    const bool result = KisResourceCacheDb::addResource(storage,
                                                        storage->timeStampForResource(resourceType, resource->filename()),
                                                        resource,
                                                        resourceType);
    return result;
}

References KisResourceCacheDb::addResource(), d, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, loadRequiredResources(), makeStorageLocationAbsolute(), and resource().

addResourceDeduplicateFileName()

bool KisResourceLocator::addResourceDeduplicateFileName ( const QString & resourceType, const KoResourceSP resource, const QString & storageLocation )

private

addResourceDeduplicateFileName imports the resource fith file name deduplication

When loading embedded resources from another resources, we should make sure they do not overwrite anything and land in the database unconditionally. That is why we might need to rename them on loading. The parent resource will (hopefully) still be able to address them using md5sum.

Parameters

resourceType
device	QIODevice where the resource should be loaded from
storageLocation	optional, the storage where the resource will be stored. Empty means in the default Folder storage.

Returns

the imported resource, which has been added to the database and the cache

Definition at line 638 of file KisResourceLocator.cpp.

{
    // fix filename is missing
    if (resource->filename().isEmpty()) {
        resource->setFilename(resource->name().split(" ").join("_") + resource->defaultFileExtension());
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!resource->filename().isEmpty(), false);
 
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(storageLocation));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, false);
 
    const QString fileName = findDeduplicatedFileName(resourceType, resource->filename(), storage);
    resource->setFilename(fileName);
    return addResource(resourceType, resource, storageLocation);
}

References addResource(), d, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, makeStorageLocationAbsolute(), and resource().

addStorage()

bool KisResourceLocator::addStorage	(	const QString &	storageLocation,
		KisResourceStorageSP	storage )

addStorage Adds a new resource storage to the database. The storage is will be marked as not pre-installed. If there is already a storage with the given location, it will first be removed.

Parameters

storageLocation	a unique name for the given storage
storage	a storage object

Returns

true if the storage has been added successfully

Definition at line 842 of file KisResourceLocator.cpp.

{
    if (d->storages.contains(storageLocation)) {
        if (!removeStorage(storageLocation)) {
            qWarning() << "could not remove" << storageLocation;
            return false;
        }
    }
 
    QVector<std::pair<QString, int>> addedResources;
    Q_FOREACH(const QString &type, KisResourceLoaderRegistry::instance()->resourceTypes()) {
        int numAddedResources = 0;
 
        QSharedPointer<KisResourceStorage::ResourceIterator> it = storage->resources(type);
        while (it->hasNext()) {
            it->next();
            numAddedResources++;
        }
 
        if (numAddedResources > 0) {
            addedResources << std::make_pair(type, numAddedResources);
        }
    }
 
    Q_FOREACH (const auto &typedResources, addedResources) {
        Q_EMIT beginExternalResourceImport(typedResources.first, typedResources.second);
    }
 
    d->storages[storageLocation] = storage;
    if (!KisResourceCacheDb::addStorage(storage, false)) {
        d->errorMessages.append(i18n("Could not add %1 to the database", storage->location()));
        qWarning() << d->errorMessages;
        return false;
    }
 
    if (!KisResourceCacheDb::addStorageTags(storage)) {
        d->errorMessages.append(QString("Could not add tags for storage %1 to the cache database").arg(storage->location()));
        qWarning() << d->errorMessages;
        return false;
    }
 
    Q_FOREACH (const auto &typedResources, addedResources) {
        Q_EMIT endExternalResourceImport(typedResources.first);
    }
 
    Q_EMIT storageAdded(makeStorageLocationRelative(storage->location()));
    return true;
}

References KisResourceCacheDb::addStorage(), KisResourceCacheDb::addStorageTags(), beginExternalResourceImport(), d, endExternalResourceImport(), KisResourceLoaderRegistry::instance(), makeStorageLocationRelative(), removeStorage(), and storageAdded().

beginExternalResourceImport

void KisResourceLocator::beginExternalResourceImport ( const QString & resourceType, int numResources )

signal

Emitted when the locator needs to add an embedded resource.

beginExternalResourceRemove

void KisResourceLocator::beginExternalResourceRemove ( const QString & resourceType, const QVector< int > resourceIds )

signal

Emitted when the locator needs to add an embedded resource.

endExternalResourceImport

void KisResourceLocator::endExternalResourceImport ( const QString & resourceType )

signal

Emitted when the locator finished importing the embedded resource.

endExternalResourceRemove

void KisResourceLocator::endExternalResourceRemove ( const QString & resourceType )

signal

Emitted when the locator finished importing the embedded resource.

errorMessages()

QStringList KisResourceLocator::errorMessages

(

)

const

errorMessages

Returns

Definition at line 150 of file KisResourceLocator.cpp.

{
    return d->errorMessages;
}

References d.

exportResource()

bool KisResourceLocator::exportResource ( KoResourceSP resource, QIODevice * device )

private

exportResource

Parameters

resource	resource to be exported
device	QIODevice where the resource should be loaded to

Returns

true if the resource has been exported successfully

Definition at line 667 of file KisResourceLocator.cpp.

{
    if (!resource || !resource->valid() || resource->resourceId() < 0) return false;
 
    const QString resourceUrl = resource->resourceType().first + "/" + resource->filename();
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(resource->storageLocation()));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, false);
    return storage->exportResource(resourceUrl, device);
}

References d, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, makeStorageLocationAbsolute(), and resource().

filePathForResource()

QString KisResourceLocator::filePathForResource

(

KoResourceSP

resource

)

Returns the full file path of the resource if it has any separate physical representation on the disk

Definition at line 1023 of file KisResourceLocator.cpp.

{
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(resource->storageLocation()));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, QString());
 
    const QString resourceUrl = resource->resourceType().first + "/" + resource->filename();
 
    return storage->resourceFilePath(resourceUrl);
}

References d, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, makeStorageLocationAbsolute(), and resource().

findStorages()

void KisResourceLocator::findStorages ( )

private

Definition at line 1095 of file KisResourceLocator.cpp.

{
    d->storages.clear();
    d->resourceCache.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");
    d->storages["memory"]->setMetaData(KisResourceStorage::s_meta_name, i18n("Temporary Resources"));
 
    // Add font storage
    auto fontStorage = QSharedPointer<KisResourceStorage>::create("fontregistry");
    if (fontStorage && fontStorage->valid()) {
        d->storages["fontregistry"] = fontStorage;
        d->storages["fontregistry"]->setMetaData(KisResourceStorage::s_meta_name, i18n("Font Storage"));
    }
 
    // 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());
        if (!storage->valid()) {
            // we still add the storage to the list and try to read whatever possible
            qWarning() << "KisResourceLocator::findStorages: the storage is invalid" << storage->location();
        }
        d->storages[storage->location()] = storage;
    }
 
    // Add any missing storage types to the resource cache database.
    Q_FOREACH(const KisResourceStorage::StorageType &type, KisStoragePluginRegistry::instance()->storageTypes()) {
        KisResourceCacheDb::registerStorageType(type);
    }
}

References d, fontStorage(), KisStoragePluginRegistry::instance(), KisResourceCacheDb::registerStorageType(), and KisResourceStorage::s_meta_name.

firstTimeInstallation()

KisResourceLocator::LocatorError KisResourceLocator::firstTimeInstallation ( InitializationStatus initializationStatus, const QString & installationResourcesLocation )

private

Definition at line 1042 of file KisResourceLocator.cpp.

{
    Q_EMIT progressMessage(i18n("Krita is running for the first time. Initialization will take some time."));
    Q_UNUSED(initializationStatus);
 
    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();
        Q_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");
    if (f.open(QFile::WriteOnly)) {
        f.write(KritaVersionWrapper::versionString().toUtf8());
        f.close();
    } else {
        qWarning() << "Could not open" << f.fileName() << "for writing:" << f.errorString();
    }
 
    return LocatorError::Ok;
}

References CannotCreateLocation, d, KisResourceLoaderRegistry::instance(), Ok, progressMessage(), and KritaVersionWrapper::versionString().

folderStorage()

KisResourceStorageSP KisResourceLocator::folderStorage ( ) const

private

Definition at line 1151 of file KisResourceLocator.cpp.

{
    return storageByLocation(d->resourceLocation);
}

References d, and storageByLocation().

fontStorage()

KisResourceStorageSP KisResourceLocator::fontStorage ( ) const

private

Definition at line 1161 of file KisResourceLocator.cpp.

{
    return storageByLocation("fontregistry");
}

References storageByLocation().

getResourceStorage()

KisResourceLocator::ResourceStorage KisResourceLocator::getResourceStorage ( int resourceId ) const

private

Definition at line 1166 of file KisResourceLocator.cpp.

{
    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;
}

References makeStorageLocationAbsolute(), KisResourceLocator::ResourceStorage::resourceFileName, KisResourceLocator::ResourceStorage::resourceType, and KisResourceLocator::ResourceStorage::storageLocation.

hasStorage()

bool KisResourceLocator::hasStorage

(

const QString &

storageLocation

)

hasStorage can be used to check whether the given storage already exists

Parameters

storageLocation

the name of the storage

Returns

true if the storage is known

Definition at line 941 of file KisResourceLocator.cpp.

{
    return d->storages.contains(document);
}

References d.

importResource()

KoResourceSP KisResourceLocator::importResource ( const QString & resourceType, const QString & fileName, QIODevice * device, const bool allowOverwrite, const QString & storageLocation = QString() )

private

importResource

Parameters

resourceType
fileName	filename that should be assigned to the resource
device	QIODevice where the resource should be loaded from
storageLocation	optional, the storage where the resource will be stored. Empty means in the default Folder storage.

Returns

the imported resource, which has been added to the database and the cache

Make sure that this resource is the latest version of the resource. Also, we cannot just return existingResource, because it has uninitialized fields. It should go through the initialization by the locator's caching system.

Definition at line 457 of file KisResourceLocator.cpp.

{
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(storageLocation));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, nullptr);
 
    QByteArray resourceData = device->readAll();
    KoResourceSP resource;
 
    {
        QBuffer buf(&resourceData);
        buf.open(QBuffer::ReadOnly);
 
        KisResourceLoaderBase *loader = KisResourceLoaderRegistry::instance()->loader(resourceType, KisMimeDatabase::mimeTypeForFile(fileName));
 
        if (!loader) {
            qWarning() << "Could not import" << fileName << ": resource doesn't load.";
            return nullptr;
        }
 
        resource = loader->load(QFileInfo(fileName).fileName(), buf, KisGlobalResourcesInterface::instance());
    }
 
    if (!resource || !resource->valid()) {
        qWarning() << "Could not import" << fileName << ": resource doesn't load.";
        return nullptr;
    }
 
    const QString md5 = KoMD5Generator::generateHash(resourceData);
    const QString resourceUrl = resourceType + "/" + resource->filename();
 
    KoResourceSP existingResource = storage->resource(resourceUrl);
 
    if (existingResource) {
        const QString existingResourceMd5Sum = storage->resourceMd5(resourceUrl);
 
        if (!allowOverwrite) {
            return nullptr;
        }
 
        if (existingResourceMd5Sum == md5 &&
            existingResource->filename() == resource->filename()) {
 
            int existingResourceId = -1;
            bool r = KisResourceCacheDb::getResourceIdFromFilename(existingResource->filename(), resourceType, storageLocation, existingResourceId);
 
            if (r && existingResourceId > 0) {
                return resourceForId(existingResourceId);
            }
        }
 
        qWarning() << "A resource with the same filename but a different MD5 already exists in the storage" << resourceType << fileName << storageLocation;
        if (storageLocation == "") {
            qWarning() << "Proceeding with overwriting the existing resource...";
            // remove all versions of the resource from the resource folder
            QStringList versionsLocations;
 
            // this resource has id -1, we need correct id
            int existingResourceId = -1;
            bool r = KisResourceCacheDb::getResourceIdFromVersionedFilename(existingResource->filename(), resourceType, storageLocation, existingResourceId);
 
            if (r && existingResourceId >= 0) {
                if (KisResourceCacheDb::getAllVersionsLocations(existingResourceId, versionsLocations)) {
 
                    for (int i = 0; i < versionsLocations.size(); i++) {
                        QFileInfo fi(this->resourceLocationBase() + "/" + resourceType + "/" + versionsLocations[i]);
                        if (fi.exists()) {
                            r = QFile::remove(fi.filePath());
                            if (!r) {
                                qWarning() << "KisResourceLocator::importResourceFromFile: Removal of " << fi.filePath()
                                           << "was requested, but it wasn't possible, something went wrong.";
                            }
                        } else {
                            qWarning() << "KisResourceLocator::importResourceFromFile: Removal of " << fi.filePath()
                                       << "was requested, but it doesn't exist.";
                        }
                    }
                } else {
                    qWarning() << "KisResourceLocator::importResourceFromFile: Finding all locations for " << existingResourceId << "was requested, but it failed.";
                    return nullptr;
                }
            } else {
                qWarning() << "KisResourceLocator::importResourceFromFile: there is no resource file found in the location of " << storageLocation << resource->filename() << resourceType;
                return nullptr;
            }
 
            Q_EMIT beginExternalResourceRemove(resourceType, {existingResourceId});
 
            // remove everything related to this resource from the database (remember about tags and versions!!!)
            r = KisResourceCacheDb::removeResourceCompletely(existingResourceId);
 
            {
                const QString absoluteStorageLocation = makeStorageLocationAbsolute(resource->storageLocation());
                KisResourceThumbnailCache::instance()->remove(absoluteStorageLocation, resourceType, existingResource->filename());
            }
 
            Q_EMIT endExternalResourceRemove(resourceType);
 
            if (!r) {
                qWarning() << "KisResourceLocator::importResourceFromFile: Removing resource with id " << existingResourceId << "completely from the database failed.";
                return nullptr;
            }
 
        } else {
            qWarning() << "KisResourceLocator::importResourceFromFile: Overwriting of the resource was denied, aborting import.";
            return nullptr;
        }
    }
 
    QBuffer buf(&resourceData);
    buf.open(QBuffer::ReadOnly);
 
    if (storage->importResource(resourceUrl, &buf)) {
        resource = storage->resource(resourceUrl);
 
        if (!resource) {
            qWarning() << "Could not retrieve imported resource from the storage" << resourceType << fileName << storageLocation;
            return nullptr;
        }
 
        resource->setStorageLocation(storageLocation);
        resource->setMD5Sum(storage->resourceMd5(resourceUrl));
        resource->setVersion(0);
        resource->setDirty(false);
        loadRequiredResources(resource);
 
        Q_EMIT beginExternalResourceImport(resourceType, 1);
 
        // Insert into the database
        const bool result = KisResourceCacheDb::addResource(storage,
                                                storage->timeStampForResource(resourceType, resource->filename()),
                                                resource,
                                                resourceType);
 
        Q_EMIT endExternalResourceImport(resourceType);
 
        if (!result) {
            return nullptr;
        }
 
        // resourceCaches use absolute locations
        const QString absoluteStorageLocation = makeStorageLocationAbsolute(resource->storageLocation());
        const QPair<QString, QString> key = {absoluteStorageLocation, resourceType + "/" + resource->filename()};
        // Add to the cache
        d->resourceCache[key] = resource;
        KisResourceThumbnailCache::instance()->insert(key, resource->thumbnail());
 
        return resource;
    }
 
    return nullptr;
}

References KisResourceCacheDb::addResource(), beginExternalResourceImport(), beginExternalResourceRemove(), d, endExternalResourceImport(), endExternalResourceRemove(), KoMD5Generator::generateHash(), KisResourceCacheDb::getAllVersionsLocations(), KisResourceCacheDb::getResourceIdFromFilename(), KisResourceCacheDb::getResourceIdFromVersionedFilename(), KisResourceThumbnailCache::insert(), KisGlobalResourcesInterface::instance(), KisResourceLoaderRegistry::instance(), KisResourceThumbnailCache::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisResourceLoaderBase::load(), KisResourceLoaderRegistry::loader(), loadRequiredResources(), makeStorageLocationAbsolute(), KisMimeDatabase::mimeTypeForFile(), KisResourceThumbnailCache::remove(), KisResourceCacheDb::removeResourceCompletely(), resource(), resourceForId(), and resourceLocationBase().

importResourceDeduplicateFileName()

KoResourceSP KisResourceLocator::importResourceDeduplicateFileName ( const QString & resourceType, const QString & proposedFileName, QIODevice * device, const QString & storageLocation = QString() )

private

importResourceDeduplicateFileName imports the resource fith file name deduplication

When loading embedded resources from another resources, we should make sure they do not overwrite anything and land in the database unconditionally. That is why we might need to rename them on loading. The parent resource will (hopefully) still be able to address them using md5sum.

Parameters

resourceType
proposedFileName	filename that should be assigned to the resource (will possibly be changed)
device	QIODevice where the resource should be loaded from
storageLocation	optional, the storage where the resource will be stored. Empty means in the default Folder storage.

Returns

the imported resource, which has been added to the database and the cache

Definition at line 629 of file KisResourceLocator.cpp.

{
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(storageLocation));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, nullptr);
 
    const QString fileName = findDeduplicatedFileName(resourceType, proposedFileName, storage);
    return importResource(resourceType, fileName, device, false, storageLocation);
}

References d, importResource(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and makeStorageLocationAbsolute().

importResourceFromFile()

KoResourceSP KisResourceLocator::importResourceFromFile ( const QString & resourceType, const QString & fileName, const bool allowOverwrite, const QString & storageLocation = QString() )

private

importResourceFromFile

Parameters

resourceType
fileName
storageLocation	optional, the storage where the resource will be stored. Empty means in the default Folder storage.

Returns

the imported resource, which has been added to the database and the cache

Definition at line 446 of file KisResourceLocator.cpp.

{
    QFile f(fileName);
    if (!f.open(QFile::ReadOnly)) {
        qWarning() << "Could not open" << fileName << "for loading";
        return nullptr;
    }
 
    return importResource(resourceType, fileName, &f, allowOverwrite, storageLocation);
}

References importResource().

importWillOverwriteResource()

bool KisResourceLocator::importWillOverwriteResource ( const QString & resourceType, const QString & fileName, const QString & storageLocation = QString() ) const

private

return whether importing will overwrite some existing resource

Parameters

resourceType
fileName	filename that should be assigned to the resource
storageLocation	optional, the storage where the resource will be stored. Empty means in the default Folder storage.

Definition at line 655 of file KisResourceLocator.cpp.

{
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(storageLocation));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, false);
 
    const QString resourceUrl = resourceType + "/" + QFileInfo(fileName).fileName();
 
    KoResourceSP existingResource = storage->resource(resourceUrl);
 
    return !existingResource.isNull();
}

References d, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and makeStorageLocationAbsolute().

initialize()

KisResourceLocator::LocatorError KisResourceLocator::initialize

(

const QString &

installationResourcesLocation

)

initialize Setup the resource locator for use.

Parameters

installationResourcesLocation

the place where the resources that come packaged with Krita reside.

Definition at line 94 of file KisResourceLocator.cpp.

{
    InitializationStatus initializationStatus = InitializationStatus::Unknown;
 
    d->resourceLocation = KoResourcePaths::getAppDataLocation();
 
    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;
        }
        initializationStatus = InitializationStatus::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 (initializationStatus != InitializationStatus::FirstRun) {
        QFile fi(d->resourceLocation + '/' + "KRITA_RESOURCE_VERSION");
        if (!fi.open(QFile::ReadOnly)) {
            initializationStatus = InitializationStatus::FirstUpdate;
        }
        else {
            QVersionNumber resource_version = QVersionNumber::fromString(QString::fromUtf8(fi.readAll()));
            QVersionNumber krita_version = QVersionNumber::fromString(KritaVersionWrapper::versionString());
            if (krita_version > resource_version) {
                initializationStatus = InitializationStatus::Updating;
            }
            else {
                initializationStatus = InitializationStatus::Initialized;
            }
        }
    }
 
    if (initializationStatus != InitializationStatus::Initialized) {
        KisResourceLocator::LocatorError res = firstTimeInstallation(initializationStatus, installationResourcesLocation);
        if (res != LocatorError::Ok) {
            return res;
        }
        initializationStatus = InitializationStatus::Initialized;
    }
 
    if (!synchronizeDb()) {
        return LocatorError::CannotSynchronizeDb;
    }
 
    return LocatorError::Ok;
}

References CannotCreateLocation, CannotSynchronizeDb, d, FirstRun, firstTimeInstallation(), FirstUpdate, KoResourcePaths::getAppDataLocation(), Initialized, LocationReadOnly, Ok, synchronizeDb(), Unknown, Updating, and KritaVersionWrapper::versionString().

instance()

KisResourceLocator * KisResourceLocator::instance ( )

static

Definition at line 79 of file KisResourceLocator.cpp.

{
    // 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;
}

References KisResourceLocator().

loadRequiredResources()

void KisResourceLocator::loadRequiredResources ( KoResourceSP resource )

private

Loads all the resources required by resource into the cache

loadRequiredResources() also loads embedded resources and adds them into the database.

First load the side-loaded resources, since they may be linked by the linked resources.

Now load the linked resources

Definition at line 168 of file KisResourceLocator.cpp.

{
    auto loadResourcesGroup =
            [this, parentResource = resource] (QList<KoResourceLoadResult> resources,
            const QString &resourceGroup) {
 
        Q_FOREACH (KoResourceLoadResult res, resources) {
            switch (res.type())
            {
            case KoResourceLoadResult::ExistingResource:
                KIS_SAFE_ASSERT_RECOVER_NOOP(res.resource()->resourceId() >= 0);
                break;
            case KoResourceLoadResult::EmbeddedResource: {
                KoResourceSignature sig = res.embeddedResource().signature();
                QByteArray data = res.embeddedResource().data();
                QBuffer buffer(&data);
                buffer.open(QBuffer::ReadOnly);
                importResourceDeduplicateFileName(sig.type, sig.filename, &buffer, "memory");
                break;
            }
            case KoResourceLoadResult::FailedLink:
                qWarning() << "Failed to load" << resourceGroup << "resource:" << res.signature();
                break;
            }
        }
    };
 
    loadResourcesGroup(resource->takeSideLoadedResources(KisGlobalResourcesInterface::instance()), "side-loaded");
 
    loadResourcesGroup(resource->requiredResources(KisGlobalResourcesInterface::instance()), "linked");
}

References KoEmbeddedResource::data(), KoResourceLoadResult::EmbeddedResource, KoResourceLoadResult::embeddedResource(), KoResourceLoadResult::ExistingResource, KoResourceLoadResult::FailedLink, KoResourceSignature::filename, importResourceDeduplicateFileName(), KisGlobalResourcesInterface::instance(), KIS_SAFE_ASSERT_RECOVER_NOOP, KoResourceLoadResult::resource(), resource(), KoEmbeddedResource::signature(), KoResourceLoadResult::signature(), KoResourceLoadResult::type(), and KoResourceSignature::type.

makeStorageLocationAbsolute()

QString KisResourceLocator::makeStorageLocationAbsolute ( QString storageLocation ) const

private

Definition at line 1207 of file KisResourceLocator.cpp.

{
//    debugResource << "makeStorageLocationAbsolute" << storageLocation;
 
    if (storageLocation.isEmpty()) {
        return resourceLocationBase();
    }
 
    if (QFileInfo(storageLocation).isRelative() && (storageLocation.endsWith(".bundle", Qt::CaseInsensitive)
                                             || storageLocation.endsWith(".asl", Qt::CaseInsensitive)
                                             || storageLocation.endsWith(".abr", Qt::CaseInsensitive))) {
        if (resourceLocationBase().endsWith('/') || resourceLocationBase().endsWith("\\")) {
            storageLocation = resourceLocationBase() + storageLocation;
        }
        else {
            storageLocation = resourceLocationBase() + '/' + storageLocation;
        }
    }
 
//    debugResource  << "\t" << storageLocation;
    return storageLocation;
}

References resourceLocationBase().

makeStorageLocationRelative()

QString KisResourceLocator::makeStorageLocationRelative ( QString location ) const

private

Definition at line 1300 of file KisResourceLocator.cpp.

{
//    debugResource << "makeStorageLocationRelative" << location << "locationbase" << resourceLocationBase();
    return location.remove(resourceLocationBase());
}

References resourceLocationBase().

memoryStorage()

KisResourceStorageSP KisResourceLocator::memoryStorage ( ) const

private

Definition at line 1156 of file KisResourceLocator.cpp.

{
    return storageByLocation("memory");
}

References storageByLocation().

metaDataForResource()

QMap< QString, QVariant > KisResourceLocator::metaDataForResource ( int id ) const

private

metaDataForResource

Parameters

id

Returns

Definition at line 791 of file KisResourceLocator.cpp.

{
    return KisResourceCacheDb::metaDataForId(id, "resources");
}

References KisResourceCacheDb::metaDataForId().

metaDataForStorage()

QMap< QString, QVariant > KisResourceLocator::metaDataForStorage ( const QString & storageLocation ) const

private

metaDataForStorage

Parameters

storage

Returns

Definition at line 801 of file KisResourceLocator.cpp.

{
    QMap<QString, QVariant> metadata;
 
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(storageLocation));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, metadata);
 
    Q_FOREACH(const QString key, storage->metaDataKeys()) {
        metadata[key] = storage->metaData(key);
    }
    return metadata;
}

References d, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and makeStorageLocationAbsolute().

operator=()

KisResourceLocator KisResourceLocator::operator= ( const KisResourceLocator & )

private

progressMessage

void KisResourceLocator::progressMessage ( const QString & )

signal

purge()

void KisResourceLocator::purge	(	const QString &	storageLocation,
		const QVector< int > &	removedTagIds )

purge purges the local resource cache

Definition at line 824 of file KisResourceLocator.cpp.

{
    Q_FOREACH(const auto key, d->resourceCache.keys()) {
        if (key.first == storageLocation) {
            d->resourceCache.remove(key);
            KisResourceThumbnailCache::instance()->remove(key);
        }
    }
 
    for (auto it = d->tagCache.begin(); it != d->tagCache.end();) {
        if (removedTagIds.contains(it.value()->id())) {
            it = d->tagCache.erase(it);
        } else {
            ++it;
        }
    }
}

References d, KisResourceThumbnailCache::instance(), and KisResourceThumbnailCache::remove().

purgeTag()

void KisResourceLocator::purgeTag	(	const QString	tagUrl,
		const QString	resourceType )

Remove the given tag from the cache

Definition at line 1018 of file KisResourceLocator.cpp.

{
    d->tagCache.remove(QPair<QString, QString>(resourceType, tagUrl));
}

References d.

reloadResource()

bool KisResourceLocator::reloadResource ( const QString & resourceType, const KoResourceSP resource )

private

Reloads the resource from its persistent storage.

Parameters

resourceType	the type of the resource
resource	the actual resource object

Returns

true if reloading was successful. When returned false, resource is kept unchanged

Definition at line 766 of file KisResourceLocator.cpp.

{
    // This resource isn't in the database yet, so we cannot reload it
    if (resource->resourceId() < 0) return false;
 
    QString storageLocation = makeStorageLocationAbsolute(resource->storageLocation());
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(storageLocation));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, false);
 
    if (!storage->loadVersionedResource(resource)) {
        qWarning() << "Failed to reload the resource" << resource->name() << "from storage" << storageLocation;
        return false;
    }
 
    resource->setMD5Sum(storage->resourceMd5(resourceType + "/" + resource->filename()));
    resource->setDirty(false);
    loadRequiredResources(resource);
 
    // We haven't changed the version of the resource, so the cache must be still valid
    QPair<QString, QString> key = QPair<QString, QString> (storageLocation, resourceType + "/" + resource->filename());
    Q_ASSERT(d->resourceCache[key] == resource);
 
    return true;
}

References d, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, loadRequiredResources(), makeStorageLocationAbsolute(), and resource().

removeStorage()

bool KisResourceLocator::removeStorage

(

const QString &

storageLocation

)

removeStorage removes the temporary storage from the database

Parameters

storageLocation

the unique name of the storage

Returns

true is successful.

Definition at line 891 of file KisResourceLocator.cpp.

{
    // Cloned documents have a document storage, but that isn't in the locator.
    if (!d->storages.contains(storageLocation)) {
        return true;
    }
 
    QVector<std::pair<QString, QVector<int>>> removedResources;
 
    Q_FOREACH(const QString &type, KisResourceLoaderRegistry::instance()->resourceTypes()) {
        const QVector<int> resources = KisResourceCacheDb::resourcesForStorage(type, storageLocation);
        if (!resources.isEmpty()) {
            removedResources << std::make_pair(type, resources);
        }
    }
 
    QVector<std::pair<QString, QVector<int>>> removedTags;
    QVector<int> allRemovedTagIds;
    Q_FOREACH(const QString &type, KisResourceLoaderRegistry::instance()->resourceTypes()) {
        auto [uniqueTags, sharedTags] = KisResourceCacheDb::tagsForStorage(type, storageLocation);
        removedTags << std::make_pair(type, uniqueTags);
        allRemovedTagIds << uniqueTags;
    }
 
    Q_FOREACH (const auto &typedResources, removedResources) {
        Q_EMIT beginExternalResourceRemove(typedResources.first, typedResources.second);
    }
 
    // TODO: add model notification about removed tags
    Q_UNUSED(removedTags);
 
    purge(storageLocation, allRemovedTagIds);
 
    KisResourceStorageSP storage = d->storages.take(storageLocation);
 
    if (!KisResourceCacheDb::deleteStorage(storage)) {
        d->errorMessages.append(i18n("Could not remove storage %1 from the database", storage->location()));
        qWarning() << d->errorMessages;
        return false;
    }
 
    Q_FOREACH (const auto &typedResources, removedResources) {
        Q_EMIT endExternalResourceRemove(typedResources.first);
    }
 
    Q_EMIT storageRemoved(makeStorageLocationRelative(storage->location()));
 
    return true;
}

References beginExternalResourceRemove(), d, KisResourceCacheDb::deleteStorage(), endExternalResourceRemove(), KisResourceLoaderRegistry::instance(), makeStorageLocationRelative(), purge(), KisResourceCacheDb::resourcesForStorage(), storageRemoved(), and KisResourceCacheDb::tagsForStorage().

resource()

KoResourceSP KisResourceLocator::resource ( QString storageLocation, const QString & resourceType, const QString & filename )

private

resource finds a physical resource in one of the storages

Parameters

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.

Parameters

resourceType	the type of the resource
filename	the filename of the resource including extension, but without any paths

Returns

A resource if found, or 0

Definition at line 331 of file KisResourceLocator.cpp.

{
    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->safeGetStorage(storageLocation);
        if (!storage) {
            return 0;
        }
 
        resource = storage->resource(resourceType + "/" + filename);
 
        if (resource) {
            d->resourceCache[key] = resource;
            // load all the embedded resources into temporary "memory" storage
            loadRequiredResources(resource);
        }
    }
 
    if (!resource) {
        qWarning() << "KoResourceSP KisResourceLocator::resource" << storageLocation << resourceType << filename << "was not found";
        return 0;
    }
 
    resource->setStorageLocation(storageLocation);
    Q_ASSERT(!resource->storageLocation().isEmpty());
 
    if (resource->resourceId() < 0 || resource->version() < 0) {
        QSqlQuery q;
        if (!q.prepare("SELECT resources.id\n"
                       ",      versioned_resources.version as version\n"
                       ",      versioned_resources.md5sum as md5sum\n"
                       ",      resources.name\n"
                       ",      resources.status\n"
                       "FROM   resources\n"
                       ",      storages\n"
                       ",      resource_types\n"
                       ",      versioned_resources\n"
                       "WHERE  storages.id = resources.storage_id\n"
                       "AND    storages.location = :storage_location\n"
                       "AND    resource_types.id = resources.resource_type_id\n"
                       "AND    resource_types.name = :resource_type\n"
                       "AND    resources.filename  = :filename\n"
                       "AND    versioned_resources.resource_id = resources.id\n"
                       "AND    versioned_resources.version = (SELECT MAX(version) FROM versioned_resources WHERE versioned_resources.resource_id = resources.id)")) {
            qWarning() << "Could not prepare id/version query" << q.lastError();
 
        }
 
        q.bindValue(":storage_location", makeStorageLocationRelative(storageLocation));
        q.bindValue(":resource_type", resourceType);
        q.bindValue(":filename", filename);
 
        if (!q.exec()) {
            qWarning() << "Could not execute id/version query" << q.lastError() << q.boundValues();
        }
 
        if (!q.first()) {
            qWarning() << "Could not find the resource in the database" << storageLocation << resourceType << filename;
        }
 
        resource->setResourceId(q.value(0).toInt());
        Q_ASSERT(resource->resourceId() >= 0);
 
        resource->setVersion(q.value(1).toInt());
        Q_ASSERT(resource->version() >= 0);
 
        resource->setMD5Sum(q.value(2).toString());
        Q_ASSERT(!resource->md5Sum().isEmpty());
 
        resource->setActive(q.value(4).toBool());
 
        // To override resources that use the filename for the name, which is versioned, and we don't want the version number in the name
        resource->setName(q.value(3).toString());;
    }
 
    if (!resource) {
        qWarning() << "Could not find resource" << resourceType + "/" + filename;
        return 0;
    }
 
    return resource;
}

References d, loadRequiredResources(), makeStorageLocationAbsolute(), makeStorageLocationRelative(), and resource().

resourceActiveStateChanged

void KisResourceLocator::resourceActiveStateChanged ( const QString & resourceType, int resourceId )

signal

Emitted when a resource changes its active state.

resourceCached()

bool KisResourceLocator::resourceCached ( QString storageLocation, const QString & resourceType, const QString & filename ) const

private

Returns

true if the resource is present in the cache, false if it hasn't been loaded

Definition at line 160 of file KisResourceLocator.cpp.

{
    storageLocation = makeStorageLocationAbsolute(storageLocation);
    QPair<QString, QString> key = QPair<QString, QString> (storageLocation, resourceType + "/" + filename);
 
    return d->resourceCache.contains(key);
}

References d, and makeStorageLocationAbsolute().

resourceForId()

KoResourceSP KisResourceLocator::resourceForId ( int resourceId )

private

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.

Parameters

resourceId

the id

Definition at line 421 of file KisResourceLocator.cpp.

{
    ResourceStorage rs = getResourceStorage(resourceId);
    KoResourceSP r = resource(rs.storageLocation, rs.resourceType, rs.resourceFileName);
    return r;
}

References getResourceStorage(), resource(), KisResourceLocator::ResourceStorage::resourceFileName, KisResourceLocator::ResourceStorage::resourceType, and KisResourceLocator::ResourceStorage::storageLocation.

resourceLocationBase()

QString KisResourceLocator::resourceLocationBase

(

)

const

resourceLocationBase is the place where all resource storages (folder, bundles etc. are located. This is a writable place.

Returns

the base location for all storages.

Definition at line 155 of file KisResourceLocator.cpp.

{
    return d->resourceLocation;
}

References d.

saveTags()

void KisResourceLocator::saveTags ( )

static

saveTags saves all tags to .tag files in the resource folder

Definition at line 946 of file KisResourceLocator.cpp.

{
    QSqlQuery query;
 
    if (!query.prepare("SELECT tags.url \n"
                       ",      resource_types.name \n"
                       "FROM   tags\n"
                       ",      resource_types\n"
                       "WHERE  tags.resource_type_id = resource_types.id\n"))
    {
        qWarning() << "Could not prepare save tags query" << query.lastError();
        return;
    }
 
    if (!query.exec()) {
        qWarning() << "Could not execute save tags query" << query.lastError();
        return;
    }
 
    // this needs to use ResourcePaths because it is sometimes called during initialization
    // (when the database versions don't match up and tags need to be saved)
    QString resourceLocation = KoResourcePaths::getAppDataLocation() + "/";
 
    while (query.next()) {
        // Save tag...
        KisTagSP tag = tagForUrlNoCache(query.value("tags.url").toString(),
                                 query.value("resource_types.name").toString());
 
        if (!tag || !tag->valid()) {
            continue;
        }
 
 
        QString filename = tag->filename();
        if (filename.isEmpty() || QFileInfo(filename).suffix().isEmpty()) {
            filename = tag->url() + ".tag";
        }
 
 
        if (QFileInfo(filename).suffix() != "tag" && QFileInfo(filename).suffix() != "TAG") {
            // it's either .abr file, or maybe a .bundle
            // or something else, but not a tag file
            dbgResources << "Skipping saving tag " << tag->name(false) << filename << tag->resourceType();
            continue;
        }
 
        filename.remove(resourceLocation);
 
        QFile f(resourceLocation + "/" + tag->resourceType() + '/' + filename);
 
        if (!f.open(QFile::WriteOnly)) {
            qWarning () << "Could not open tag file for writing" << f.fileName();
            continue;
        }
 
        QBuffer buf;
        buf.open(QIODevice::WriteOnly);;
 
        if (!tag->save(buf)) {
            qWarning() << "Could not save tag to" << f.fileName();
            buf.close();
            f.close();
            continue;
        }
 
        f.write(buf.data());
        f.flush();
 
        f.close();
    }
}

References dbgResources, KoResourcePaths::getAppDataLocation(), and tagForUrlNoCache().

setMetaDataForResource()

bool KisResourceLocator::setMetaDataForResource ( int id, QMap< QString, QVariant > map ) const

private

setMetaDataForResource

Parameters

id
map

Returns

Definition at line 796 of file KisResourceLocator.cpp.

{
    return KisResourceCacheDb::updateMetaDataForId(map, id, "resources");
}

References KisResourceCacheDb::updateMetaDataForId().

setMetaDataForStorage()

void KisResourceLocator::setMetaDataForStorage ( const QString & storageLocation, QMap< QString, QVariant > map ) const

private

setMetaDataForStorage

Parameters

storage
map

Definition at line 814 of file KisResourceLocator.cpp.

{
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(storageLocation));
    KIS_SAFE_ASSERT_RECOVER_RETURN(storage);
 
    Q_FOREACH(const QString &key, map.keys()) {
        storage->setMetaData(key, map[key]);
    }
}

References d, KIS_SAFE_ASSERT_RECOVER_RETURN, and makeStorageLocationAbsolute().

setResourceActive()

bool KisResourceLocator::setResourceActive ( int resourceId, bool active )

private

setResourceActive

Parameters

resourceId
active	shows if the resource should be set as active or not

Returns

Definition at line 428 of file KisResourceLocator.cpp.

{
    // 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);
    if (!active) {
        KisResourceThumbnailCache::instance()->remove(key);
    }
 
    bool result = KisResourceCacheDb::setResourceActive(resourceId, active);
 
    Q_EMIT resourceActiveStateChanged(rs.resourceType, resourceId);
 
    return result;
}

References d, getResourceStorage(), KisResourceThumbnailCache::instance(), KisResourceThumbnailCache::remove(), resourceActiveStateChanged(), KisResourceLocator::ResourceStorage::resourceFileName, KisResourceLocator::ResourceStorage::resourceType, KisResourceCacheDb::setResourceActive(), and KisResourceLocator::ResourceStorage::storageLocation.

storageAdded

void KisResourceLocator::storageAdded ( const QString & location )

signal

Emitted whenever a storage is added.

storageByLocation()

KisResourceStorageSP KisResourceLocator::storageByLocation ( const QString & location ) const

private

Definition at line 1140 of file KisResourceLocator.cpp.

{
    KisResourceStorageSP storage = d->safeGetStorage(location);
    if (!storage || !storage->valid()) {
        qWarning() << "Could not retrieve the" << location << "storage object or the object is not valid";
        return 0;
    }
 
    return storage;
}

References d.

storageRemoved

void KisResourceLocator::storageRemoved ( const QString & location )

signal

Emitted whenever a storage is removed.

storageResynchronized

void KisResourceLocator::storageResynchronized ( const QString & storage, bool isBulkResynchronization )

signal

Emitted when a storage is resynchronized using KisresourceCacheDb::synchronizeStorage()

if isBulkResynchronization then this resynchronization happened as a part of bulk resynchronization at the start of Krita. At the end of this bulk action storagesBulkSynchronizationFinished() will be emitted as well.

storages()

QList< KisResourceStorageSP > KisResourceLocator::storages ( ) const

private

Definition at line 1135 of file KisResourceLocator.cpp.

{
    return d->storages.values();
}

References d.

storagesBulkSynchronizationFinished

void KisResourceLocator::storagesBulkSynchronizationFinished ( )

signal

Emitted when bulk-synchronization of all the storages has been finished

See also

storageResynchronized

synchronizeDb()

bool KisResourceLocator::synchronizeDb ( )

private

In the current layout of the database we cannot set FOREIGN KEY for the metadata table (since it links to both, resources and storages), hence we should manually track the orphaned data.

Theoretically, these should be none, if our code is correct, but who knows anything about our code...

Definition at line 1230 of file KisResourceLocator.cpp.

{
    Q_EMIT progressMessage(i18n("Synchronizing the resources."));
 
    d->errorMessages.clear();
 
    // Add resource types that have been added since first-time installation.
    Q_FOREACH(auto loader, KisResourceLoaderRegistry::instance()->values()) {
        KisResourceCacheDb::registerResourceType(loader->resourceType());
    }
 
 
    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()));
        } else {
            Q_EMIT storageResynchronized(storage->location(), true);
        }
    }
 
    Q_FOREACH(const KisResourceStorageSP storage, d->storages) {
        if (!KisResourceCacheDb::addStorageTags(storage)) {
            d->errorMessages.append(i18n("Could not synchronize %1 with the database", storage->location()));
        }
    }
 
    Q_EMIT storagesBulkSynchronizationFinished();
 
    KisResourceCacheDb::removeOrphanedMetaData();
 
    // now remove the storages that no longer exists
    KisStorageModel model;
 
    QList<QString> storagesToRemove;
    for (int i = 0; i < model.rowCount(); i++) {
        QModelIndex idx = model.index(i, 0);
        QString location = model.data(idx, Qt::UserRole + KisStorageModel::Location).toString();
        storagesToRemove << location;
    }
 
    for (int i = 0; i < storagesToRemove.size(); i++) {
        QString location = storagesToRemove[i];
        if (!d->storages.contains(this->makeStorageLocationAbsolute(location))) {
            if (!KisResourceCacheDb::deleteStorage(location)) {
                d->errorMessages.append(i18n("Could not remove storage %1 from the database", this->makeStorageLocationAbsolute(location)));
                qWarning() << d->errorMessages;
                return false;
            }
            Q_EMIT storageRemoved(this->makeStorageLocationAbsolute(location));
        }
    }
 
 
    d->errorMessages <<
        KisResourceLoaderRegistry::instance()->executeAllFixups();
 
    d->resourceCache.clear();
    return d->errorMessages.isEmpty();
}

References KisResourceCacheDb::addStorageTags(), d, KisStorageModel::data(), KisResourceCacheDb::deleteStorage(), KisResourceLoaderRegistry::executeAllFixups(), findStorages(), KisResourceLoaderRegistry::instance(), KisStorageModel::Location, makeStorageLocationAbsolute(), progressMessage(), KisResourceCacheDb::registerResourceType(), KisResourceCacheDb::removeOrphanedMetaData(), KisStorageModel::rowCount(), storageRemoved(), storageResynchronized(), storagesBulkSynchronizationFinished(), and KisResourceCacheDb::synchronizeStorage().

tagForUrl()

KisTagSP KisResourceLocator::tagForUrl ( const QString & tagUrl, const QString resourceType )

private

tagForUrl create a tag from the database

Parameters

tagUrl

the url

Returns

a complete tag with all translated names and comments.

Definition at line 207 of file KisResourceLocator.cpp.

{
    if (d->tagCache.contains(QPair<QString, QString>(resourceType, tagUrl))) {
        return d->tagCache[QPair<QString, QString>(resourceType, tagUrl)];
    }
 
    KisTagSP tag = tagForUrlNoCache(tagUrl, resourceType);
 
    if (tag && tag->valid()) {
        d->tagCache[QPair<QString, QString>(resourceType, tagUrl)] = tag;
    }
 
    return tag;
}

References d, and tagForUrlNoCache().

tagForUrlNoCache()

KisTagSP KisResourceLocator::tagForUrlNoCache ( const QString & tagUrl, const QString resourceType )

staticprivate

tagForUrlNoCache create a tag from the database, don't use cache

Parameters

tagUrl	url of the tag
resourceType	resource type of the tag

Returns

Definition at line 222 of file KisResourceLocator.cpp.

{
    QSqlQuery query;
    bool r = query.prepare("SELECT tags.id\n"
                           ",      tags.url\n"
                           ",      tags.active\n"
                           ",      tags.name\n"
                           ",      tags.comment\n"
                           ",      tags.filename\n"
                           ",      resource_types.name as resource_type\n"
                           ",      resource_types.id\n"
                           "FROM   tags\n"
                           ",      resource_types\n"
                           "WHERE  tags.resource_type_id = resource_types.id\n"
                           "AND    resource_types.name = :resource_type\n"
                           "AND    tags.url = :tag_url\n");
 
    if (!r) {
        qWarning() << "Could not prepare KisResourceLocator::tagForUrl query" << query.lastError();
        return KisTagSP();
    }
 
    query.bindValue(":resource_type", resourceType);
    query.bindValue(":tag_url", tagUrl);
 
    r = query.exec();
    if (!r) {
        qWarning() << "Could not execute KisResourceLocator::tagForUrl query" << query.lastError() << query.boundValues();
        return KisTagSP();
    }
 
    r = query.first();
    if (!r) {
        return KisTagSP();
    }
 
    KisTagSP tag(new KisTag());
 
    int tagId = query.value("tags.id").toInt();
    int resourceTypeId = query.value("resource_types.id").toInt();
 
    tag->setUrl(query.value("url").toString());
    tag->setResourceType(resourceType);
    tag->setId(query.value("id").toInt());
    tag->setActive(query.value("active").toBool());
    tag->setName(query.value("name").toString());
    tag->setComment(query.value("comment").toString());
    tag->setFilename(query.value("filename").toString());
    tag->setValid(true);
 
 
    QMap<QString, QString> names;
    QMap<QString, QString> comments;
 
    r = query.prepare("SELECT language\n"
                      ",      name\n"
                      ",      comment\n"
                      "FROM   tag_translations\n"
                      "WHERE  tag_id = :id");
 
    if (!r) {
        qWarning() << "Could not prepare KisResourceLocator::tagForUrl translation query" << query.lastError();
    }
 
    query.bindValue(":id", tag->id());
 
    if (!query.exec()) {
        qWarning() << "Could not execute KisResourceLocator::tagForUrl translation query" << query.lastError();
    }
 
    while (query.next()) {
        names[query.value(0).toString()] = query.value(1).toString();
        comments[query.value(0).toString()] = query.value(2).toString();
    }
 
    tag->setNames(names);
    tag->setComments(comments);
 
    QSqlQuery defaultResourcesQuery;
 
    if (!defaultResourcesQuery.prepare("SELECT resources.filename\n"
                                       "FROM   resources\n"
                                       ",      resource_tags\n"
                                       "WHERE  resource_tags.tag_id = :tag_id\n"
                                       "AND    resources.resource_type_id = :type_id\n"
                                       "AND    resource_tags.resource_id = resources.id\n"
                                       "AND    resource_tags.active = 1\n")) {
        qWarning() << "Could not prepare resource/tag query" << defaultResourcesQuery.lastError();
    }
 
    defaultResourcesQuery.bindValue(":tag_id", tagId);
    defaultResourcesQuery.bindValue(":type_id", resourceTypeId);
 
    if (!defaultResourcesQuery.exec()) {
        qWarning() << "Could not execute resource/tag query" << defaultResourcesQuery.lastError();
    }
 
    QStringList resourceFileNames;
 
    while (defaultResourcesQuery.next()) {
        resourceFileNames << defaultResourcesQuery.value("resources.filename").toString();
    }
 
    tag->setDefaultResources(resourceFileNames);
 
    return tag;
}

updateFontStorage()

void KisResourceLocator::updateFontStorage

(

)

This updates the "fontregistry" storage. Called when the font directories change;.

Definition at line 1033 of file KisResourceLocator.cpp.

{
    if (!KisResourceCacheDb::synchronizeStorage(fontStorage())) {
        qWarning() << i18n("Could not synchronize updated font registry with the database");
    } else {
        Q_EMIT storageResynchronized(fontStorage()->location(), false);
    }
}

References fontStorage(), storageResynchronized(), and KisResourceCacheDb::synchronizeStorage().

updateResource()

bool KisResourceLocator::updateResource ( const QString & resourceType, const KoResourceSP resource )

private

updateResource

Parameters

resourceType
resource

Returns

Definition at line 718 of file KisResourceLocator.cpp.

{
    QString storageLocation = makeStorageLocationAbsolute(resource->storageLocation());
 
    KisResourceStorageSP storage = d->safeGetStorage(makeStorageLocationAbsolute(storageLocation));
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storage, false);
 
    if (resource->resourceId() < 0) {
        return addResource(resourceType, resource);
    }
 
    if (!storage->supportsVersioning()) return false;
 
    // remove older version
    KisResourceThumbnailCache::instance()->remove(storageLocation, resourceType, resource->filename());
 
    resource->updateThumbnail();
    resource->setVersion(resource->version() + 1);
    resource->setActive(true);
 
    if (!storage->saveAsNewVersion(resource)) {
        qWarning() << "Failed to save the new version of " << resource->name() << "to storage" << storageLocation;
        return false;
    }
 
    resource->setMD5Sum(storage->resourceMd5(resourceType + "/" + resource->filename()));
    resource->setDirty(false);
    loadRequiredResources(resource);
 
    // 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;
    }
 
    if (!setMetaDataForResource(resource->resourceId(), resource->metadata())) {
        qWarning() << "Failed to update resource metadata" << resource;
        return false;
    }
 
    // Update the resource in the cache
    QPair<QString, QString> key = QPair<QString, QString> (storageLocation, resourceType + "/" + resource->filename());
    d->resourceCache[key] = resource;
    KisResourceThumbnailCache::instance()->insert(key, resource->thumbnail());
 
    return true;
}

References addResource(), KisResourceCacheDb::addResourceVersion(), d, KisResourceThumbnailCache::insert(), KisResourceThumbnailCache::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, loadRequiredResources(), makeStorageLocationAbsolute(), KisResourceThumbnailCache::remove(), resource(), and setMetaDataForResource().

Friends And Related Symbol Documentation

KisAllResourcesModel

friend class KisAllResourcesModel

friend

Definition at line 166 of file KisResourceLocator.h.

KisAllTagResourceModel

friend class KisAllTagResourceModel

friend

Definition at line 167 of file KisResourceLocator.h.

KisAllTagsModel

friend class KisAllTagsModel

friend

Definition at line 164 of file KisResourceLocator.h.

KisBrushTypeMetaDataFixup

friend class KisBrushTypeMetaDataFixup

friend

Definition at line 176 of file KisResourceLocator.h.

KisMyPaintPaintOpPreset

friend class KisMyPaintPaintOpPreset

friend

Definition at line 387 of file KisResourceLocator.h.

KisResourceCacheDb

friend class KisResourceCacheDb

friend

Definition at line 172 of file KisResourceLocator.h.

KisResourceQueryMapper

friend class KisResourceQueryMapper

friend

Definition at line 174 of file KisResourceLocator.h.

KisResourceThumbnailCache

friend class KisResourceThumbnailCache

friend

Definition at line 177 of file KisResourceLocator.h.

KisResourceUserOperations

friend class KisResourceUserOperations

friend

Definition at line 175 of file KisResourceLocator.h.

KisStorageFilterProxyModel

friend class KisStorageFilterProxyModel

friend

Definition at line 173 of file KisResourceLocator.h.

KisStorageModel

friend class KisStorageModel

friend

Definition at line 168 of file KisResourceLocator.h.

KisTagResourceModel

friend class KisTagResourceModel

friend

Definition at line 165 of file KisResourceLocator.h.

Resource

friend class Resource

friend

Definition at line 171 of file KisResourceLocator.h.

TestResourceLocator

friend class TestResourceLocator

friend

Definition at line 169 of file KisResourceLocator.h.

TestResourceModel

friend class TestResourceModel

friend

Definition at line 170 of file KisResourceLocator.h.

Member Data Documentation

d

QScopedPointer<Private> KisResourceLocator::d

private

Definition at line 394 of file KisResourceLocator.h.

resourceLocationKey

const QString KisResourceLocator::resourceLocationKey {"ResourceDirectory"}

static

Definition at line 47 of file KisResourceLocator.h.

{

---

The documentation for this class was generated from the following files:

• libs/resources/KisResourceLocator.h
• libs/resources/KisResourceLocator.cpp