KoResourcePaths Class Reference

#include <KoResourcePaths.h>

Inheritance diagram for KoResourcePaths:

Public Types
enum	SearchOption { NoSearchOptions = 0 , Recursive = 1 , IgnoreExecBit = 4 }

Public Member Functions
QStringList	aliases (const QString &type)
	KoResourcePaths ()
QStandardPaths::StandardLocation	mapTypeToQStandardPaths (const QString &type)
virtual	~KoResourcePaths ()

Static Public Member Functions
static void	addAssetDir (const QString &type, const QString &dir, bool priority=true)
static void	addAssetType (const QString &type, const char *basetype, const QString &relativeName, bool priority=true)
static QStringList	assetDirs (const QString &type)
static QStringList	findAllAssets (const QString &type, const QString &filter=QString(), SearchOptions options=NoSearchOptions)
static QString	findAsset (const QString &type, const QString &fileName)
static QStringList	findDirs (const QString &type)
static void	getAllUserResourceFoldersLocationsForWindowsStore (QString &standardLocation, QString &privateLocation)
	getAllAppDataLocationsForWindowsStore Use this to get both private and general appdata folders which also considers user's choice of custom resource folder Used in GeneralTab in kis_dlg_preferences, and KisViewManager::openResourceDirectory().
static QString	getAppDataLocation ()
static QString	getApplicationRoot ()
static QString	locate (const QString &type, const QString &filename)
static QString	locateLocal (const QString &type, const QString &filename, bool createDir=false)
static QString	saveLocation (const QString &type, const QString &suffix=QString(), bool create=true)

Public Attributes
QMap< QString, QStringList >	absolutes
QMutex	absolutesMutex
QMap< QString, QStringList >	relatives
QMutex	relativesMutex

Static Public Attributes
static QString	s_overrideAppDataLocation
	getAppDataLocation Use this instead of QStandardPaths::AppDataLocation! The user can configure the location where resources and other user writable items are stored now.

Private Member Functions
void	addResourceDirInternal (const QString &type, const QString &absdir, bool priority)
void	addResourceTypeInternal (const QString &type, const QString &basetype, const QString &relativeName, bool priority)
QStringList	findAllResourcesInternal (const QString &type, const QString &filter=QString(), SearchOptions options=NoSearchOptions) const
QStringList	findDirsInternal (const QString &type)
QStringList	findExtraResourceDirs () const
QString	findResourceInternal (const QString &type, const QString &fileName)
QString	locateInternal (const QString &type, const QString &filename)
QString	locateLocalInternal (const QString &type, const QString &filename, bool createDir=false)
QStringList	resourceDirsInternal (const QString &type)
QString	saveLocationInternal (const QString &type, const QString &suffix=QString(), bool create=true)
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes
QScopedPointer< Private >	d
Private Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Detailed Description

The usual place to look for assets is Qt's AppDataLocation. This corresponds to XDG_DATA_DIRS on Linux. To ensure your installation and path are configured correctly, ensure your files are located in the directories contained in this variable:

QStandardPaths::standardLocations(QStandardPaths::AppDataLocation);

This can be overridden in Krita's configuration.

Unfortunately, we are mixing up two things in the appdatalocation:

• resources: brushes, presets and so on
• assets: color themes, icc profiles and other weird stuff

There are many debug lines that can be uncommented for more specific installation checks. In the future these should be converted to qloggingcategory to enable convenient enable/disable functionality.

Note: DO NOT USE THIS CLASS WHEN LOCATING RESOURCES LIKE BRUSHES OR GRADIENTS. Use KisResourceLocator instead.

Definition at line 156 of file KoResourcePaths.cpp.

Member Enumeration Documentation

SearchOption

enum KoResourcePaths::SearchOption

Enumerator
NoSearchOptions
Recursive
IgnoreExecBit

Definition at line 45 of file KoResourcePaths.h.

                      { NoSearchOptions = 0,
                        Recursive = 1,
                        IgnoreExecBit = 4
                      };

Constructor & Destructor Documentation

KoResourcePaths()

KoResourcePaths::KoResourcePaths

(

)

Definition at line 205 of file KoResourcePaths.cpp.

    : d(new Private)
{
}

~KoResourcePaths()

KoResourcePaths::~KoResourcePaths ( )

virtual

Definition at line 210 of file KoResourcePaths.cpp.

{
}

Member Function Documentation

addAssetDir()

void KoResourcePaths::addAssetDir ( const QString & type, const QString & dir, bool priority = true )

static

Adds absolute path at the beginning of the search path for particular types (for example in case of icons where the user specifies extra paths).

You shouldn't need this function in 99% of all cases besides adding user-given paths.

Parameters

type	Specifies a short descriptive string to access files of this type.
absdir	Points to directory where to look for this specific type. Nonexistent directories may be saved but pruned.
priority	if true, the directory is added before any other, otherwise after

Definition at line 304 of file KoResourcePaths.cpp.

{
    s_instance->addResourceDirInternal(type, dir, priority);
}

addAssetType()

void KoResourcePaths::addAssetType ( const QString & type, const char * basetype, const QString & relativeName, bool priority = true )

static

Adds suffixes for asset types.

You may add as many as you need, but it is advised that there is exactly one to make writing definite.

The later a suffix is added, the higher its priority. Note, that the suffix should end with / but doesn't have to start with one (as prefixes should end with one). So adding a suffix for app_pics would look like KoStandardPaths::addResourceType("app_pics", "data", "app/pics");

Parameters

type	Specifies a short descriptive string to access files of this type.
basetype	Specifies an already known type, or 0 if none
relativename	Specifies a directory relative to the basetype
priority	if true, the directory is added before any other, otherwise after

Definition at line 298 of file KoResourcePaths.cpp.

{
    s_instance->addResourceTypeInternal(type, QString::fromLatin1(basetype), relativeName, priority);
}

addResourceDirInternal()

void KoResourcePaths::addResourceDirInternal ( const QString & type, const QString & absdir, bool priority )

private

Definition at line 376 of file KoResourcePaths.cpp.

{
    if (absdir.isEmpty() || type.isEmpty()) return;
 
    // find or insert entry in the map
    QString copy = absdir;
    if (copy.at(copy.length() - 1) != QLatin1Char('/')) {
        copy += QLatin1Char('/');
    }
 
    d->absolutesMutex.lock();
    QStringList &paths = d->absolutes[type];
    if (!paths.contains(copy, cs)) {
        if (priority) {
            paths.prepend(copy);
        } else {
            paths.append(copy);
        }
    }
    d->absolutesMutex.unlock();
 
    dbgResources << "addResourceDir: type" << type << "absdir" << absdir << "priority" << priority << d->absolutes[type];
}

References d, and dbgResources.

addResourceTypeInternal()

void KoResourcePaths::addResourceTypeInternal ( const QString & type, const QString & basetype, const QString & relativeName, bool priority )

private

Definition at line 346 of file KoResourcePaths.cpp.

{
    Q_UNUSED(basetype);
    if (relativename.isEmpty()) return;
 
    QString copy = relativename;
 
    Q_ASSERT(basetype == "data");
 
    if (!copy.endsWith(QLatin1Char('/'))) {
        copy += QLatin1Char('/');
    }
 
    d->relativesMutex.lock();
    QStringList &rels = d->relatives[type]; // find or insert
 
    if (!rels.contains(copy, cs)) {
        if (priority) {
            rels.prepend(copy);
        } else {
            rels.append(copy);
        }
    }
    d->relativesMutex.unlock();
 
    dbgResources << "addResourceType: type" << type << "basetype" << basetype << "relativename" << relativename << "priority" << priority << d->relatives[type];
}

References d, and dbgResources.

aliases()

QStringList KoResourcePaths::aliases ( const QString & type )

inline

Definition at line 164 of file KoResourcePaths.cpp.

    {
        QStringList r;
        QStringList a;
        relativesMutex.lock();
        if (relatives.contains(type)) {
            r += relatives[type];
        }
        relativesMutex.unlock();
        absolutesMutex.lock();
        if (absolutes.contains(type)) {
            a += absolutes[type];
        }
        absolutesMutex.unlock();
 
        return r + a;
    }

assetDirs()

QStringList KoResourcePaths::assetDirs ( const QString & type )

static

Parameters

type	The type of resource

Returns

The list of possible directories for the specified type. The function updates the cache if possible. If the resource type specified is unknown, it will return an empty list. Note, that the directories are assured to exist beside the save location, which may not exist, but is returned anyway.

Definition at line 326 of file KoResourcePaths.cpp.

{
    return cleanupDirs(s_instance->resourceDirsInternal(type));
}

findAllAssets()

QStringList KoResourcePaths::findAllAssets ( const QString & type, const QString & filter = QString(), SearchOptions options = NoSearchOptions )

static

Tries to find all resources with the specified type.

The function will look into all specified directories and return all filenames in these directories.

The "most local" files are returned before the "more global" files.

Parameters

type	The type of resource to locate directories for.
filter	Only accept filenames that fit to filter. The filter may consist of an optional directory and a QRegExp wildcard expression. E.g. "images\*.jpg". Use QString() if you do not want a filter.
options	if the flags passed include Recursive, subdirectories will also be search.

Returns

List of all the files whose filename matches the specified filter.

Definition at line 319 of file KoResourcePaths.cpp.

{
    return cleanup(s_instance->findAllResourcesInternal(type, filter, options));
}

findAllResourcesInternal()

QStringList KoResourcePaths::findAllResourcesInternal ( const QString & type, const QString & filter = QString(), SearchOptions options = NoSearchOptions ) const

private

Definition at line 532 of file KoResourcePaths.cpp.

{
    dbgResources << "=====================================================";
    dbgResources << type << _filter << QStandardPaths::standardLocations(d->mapTypeToQStandardPaths(type));
 
    bool recursive = options & KoResourcePaths::Recursive;
 
    dbgResources << "findAllResources: type" << type << "filter" << _filter << "recursive" << recursive;
 
    QStringList aliases = d->aliases(type);
    QString filter = _filter;
 
    // In cases where the filter  is like "color-schemes/*.colors" instead of "*.kpp", used with unregistered resource types
    if (filter.indexOf('*') > 0) {
        aliases << filter.split('*').first();
        filter = '*' + filter.split('*')[1];
        dbgResources << "Split up alias" << aliases << "filter" << filter;
    }
 
    QStringList resources;
    if (aliases.isEmpty()) {
        QStringList standardResources =
                QStandardPaths::locateAll(d->mapTypeToQStandardPaths(type),
                                          filter, QStandardPaths::LocateFile);
        dbgResources << "standardResources" << standardResources;
        appendResources(&resources, standardResources, true);
        dbgResources << "1" << resources;
    }
 
    QStringList extraResourceDirs = findExtraResourceDirs();
 
    if (!extraResourceDirs.isEmpty()) {
        Q_FOREACH(const QString &extraResourceDir, extraResourceDirs) {
            if (aliases.isEmpty()) {
                appendResources(&resources, filesInDir(extraResourceDir + '/' + type, filter, recursive), true);
            }
            else {
                Q_FOREACH (const QString &alias, aliases) {
                    appendResources(&resources, filesInDir(extraResourceDir + '/' + alias + '/', filter, recursive), true);
                }
            }
        }
 
    }
 
    dbgResources << "\tresources from qstandardpaths:" << resources.size();
 
    Q_FOREACH (const QString &alias, aliases) {
        dbgResources << "\t\talias:" << alias;
        QStringList dirs;
 
        QFileInfo dirInfo(alias);
        if (dirInfo.exists() && dirInfo.isDir() && dirInfo.isAbsolute()) {
            dirs << alias;
        } else {
            dirs << QStandardPaths::locateAll(d->mapTypeToQStandardPaths(type), alias, QStandardPaths::LocateDirectory)
                 << getInstallationPrefix() + "share/" + alias + "/"
                 << getInstallationPrefix() + "share/krita/" + alias + "/";
        }
 
        Q_FOREACH (const QString &dir, dirs) {
            appendResources(&resources,
                            filesInDir(dir, filter, recursive),
                            true);
        }
    }
 
    dbgResources << "\tresources also from aliases:" << resources.size();
 
    // if the original filter is "input/*", we only want share/input/* and share/krita/input/* here, but not
    // share/*. therefore, use _filter here instead of filter which was split into alias and "*".
    QFileInfo fi(_filter);
 
    QStringList prefixResources;
    prefixResources << filesInDir(getInstallationPrefix() + "share/" + fi.path(), fi.fileName(), false);
    prefixResources << filesInDir(getInstallationPrefix() + "share/krita/" + fi.path(), fi.fileName(), false);
    appendResources(&resources, prefixResources, true);
 
    dbgResources << "\tresources from installation:" << resources.size();
    dbgResources << "=====================================================";
 
    return resources;
}

References aliases(), d, dbgResources, filesInDir(), findExtraResourceDirs(), and Recursive.

findAsset()

QString KoResourcePaths::findAsset ( const QString & type, const QString & fileName )

static

Tries to find a resource in the following order:

• All PREFIX/<relativename> paths (most recent first).
• All absolute paths (most recent first).

The filename should be a filename relative to the base dir for resources. So it's a way to get the path to libkdecore.la to findResource("lib", "libkdecore.la"). KStandardDirs will then look into the subdir lib of all elements of all prefixes ($KDEDIRS) for a file libkdecore.la and return the path to the first one it finds (e.g. /opt/kde/lib/libkdecore.la).

Example:

QString iconfilename = KStandardPaths::findResource("icon",QString("oxygen/22x22/apps/ktip.png"));

Parameters

type	The type of the wanted resource
filename	A relative filename of the resource.

Returns

A full path to the filename specified in the second argument, or QString() if not found.

Definition at line 309 of file KoResourcePaths.cpp.

{
    return cleanup(s_instance->findResourceInternal(type, fileName));
}

findDirs()

QStringList KoResourcePaths::findDirs ( const QString & type )

static

Tries to find all directories whose names consist of the specified type and a relative path. So findDirs("xdgdata-apps", "Settings") would return

• /home/joe/.local/share/applications/Settings/
• /usr/share/applications/Settings/

(from the most local to the most global)

Note that it appends / to the end of the directories, so you can use this right away as directory names.

Parameters

type	The type of the base directory.
reldir	Relative directory.

Returns

A list of matching directories, or an empty list if the resource specified is not found.

Definition at line 314 of file KoResourcePaths.cpp.

{
    return cleanupDirs(s_instance->findDirsInternal(type));
}

findDirsInternal()

QStringList KoResourcePaths::findDirsInternal ( const QString & type )

private

Definition at line 490 of file KoResourcePaths.cpp.

{
    QStringList aliases = d->aliases(type);
    dbgResources << type << aliases << d->mapTypeToQStandardPaths(type);
 
    QStringList dirs;
    QStringList standardDirs =
            QStandardPaths::locateAll(d->mapTypeToQStandardPaths(type), "", QStandardPaths::LocateDirectory);
 
    appendResources(&dirs, standardDirs, true);
 
    Q_FOREACH (const QString &alias, aliases) {
        QStringList aliasDirs =
                QStandardPaths::locateAll(d->mapTypeToQStandardPaths(type), alias + '/', QStandardPaths::LocateDirectory);
        appendResources(&dirs, aliasDirs, true);
 
#ifdef Q_OS_MACOS
        dbgResources << "MAC:" << getApplicationRoot();
        QStringList bundlePaths;
        bundlePaths << getApplicationRoot() + "/share/krita/" + alias;
        bundlePaths << getApplicationRoot() + "/../share/krita/" + alias;
        dbgResources << "bundlePaths" << bundlePaths;
        appendResources(&dirs, bundlePaths, true);
        Q_ASSERT(!dirs.isEmpty());
#endif
 
        QStringList fallbackPaths;
        fallbackPaths << getApplicationRoot() + "/share/" + alias;
        fallbackPaths << getApplicationRoot() + "/share/krita/" + alias;
        appendResources(&dirs, fallbackPaths, true);
 
    }
 
    QStringList saveLocationList;
    saveLocationList << saveLocation(type, QString(), true);
    appendResources(&dirs, saveLocationList, true);
 
    dbgResources << "findDirs: type" << type << "resource" << dirs;
    return dirs;
}

References aliases(), d, dbgResources, getApplicationRoot(), and saveLocation().

findExtraResourceDirs()

QStringList KoResourcePaths::findExtraResourceDirs ( ) const

private

Definition at line 714 of file KoResourcePaths.cpp.

{
    QStringList extraResourceDirs =
        QString::fromUtf8(qgetenv("EXTRA_RESOURCE_DIRS"))
            .split(';', Qt::SkipEmptyParts);
 
    const KConfigGroup cfg(KSharedConfig::openConfig(), "");
    const QString customPath =
        cfg.readEntry(KisResourceLocator::resourceLocationKey, "");
    if (!customPath.isEmpty()) {
        extraResourceDirs << customPath;
    }
 
    if (getAppDataLocation() != QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)) {
        extraResourceDirs << getAppDataLocation();
    }
 
    return extraResourceDirs;
}

References getAppDataLocation(), and KisResourceLocator::resourceLocationKey.

findResourceInternal()

QString KoResourcePaths::findResourceInternal ( const QString & type, const QString & fileName )

private

Definition at line 400 of file KoResourcePaths.cpp.

{
    QStringList aliases = d->aliases(type);
    dbgResources<< "aliases" << aliases << getApplicationRoot();
    QString resource = QStandardPaths::locate(QStandardPaths::AppDataLocation, fileName, QStandardPaths::LocateFile);
 
    if (resource.isEmpty()) {
        Q_FOREACH (const QString &alias, aliases) {
            resource = QStandardPaths::locate(d->mapTypeToQStandardPaths(type), alias + '/' + fileName, QStandardPaths::LocateFile);
            if (QFile::exists(resource)) {
                break;
            }
        }
    }
    if (resource.isEmpty() || !QFile::exists(resource)) {
        QString approot = getApplicationRoot();
        Q_FOREACH (const QString &alias, aliases) {
            resource = approot + "/share/" + alias + '/' + fileName;
            if (QFile::exists(resource)) {
                break;
            }
        }
    }
    if (resource.isEmpty() || !QFile::exists(resource)) {
        QString approot = getApplicationRoot();
        Q_FOREACH (const QString &alias, aliases) {
            resource = approot + "/share/krita/" + alias + '/' + fileName;
            if (QFile::exists(resource)) {
                break;
            }
        }
    }
 
    if (resource.isEmpty() || !QFile::exists(resource)) {
        QStringList extraResourceDirs = findExtraResourceDirs();
 
        if (!extraResourceDirs.isEmpty()) {
            Q_FOREACH(const QString &extraResourceDir, extraResourceDirs) {
                if (aliases.isEmpty()) {
                    resource = extraResourceDir + '/' + fileName;
                    dbgResources<< "\t4" << resource;
                    if (QFile::exists(resource)) {
                        break;
                    }
                }
                else {
                    Q_FOREACH (const QString &alias, aliases) {
                        resource = extraResourceDir + '/' + alias + '/' + fileName;
                        dbgResources<< "\t4" << resource;
                        if (QFile::exists(resource)) {
                            break;
                        }
                    }
                }
            }
        }
    }
 
    dbgResources<< "findResource: type" << type << "filename" << fileName << "resource" << resource;
    Q_ASSERT(!resource.isEmpty());
    return resource;
}

References aliases(), d, dbgResources, findExtraResourceDirs(), and getApplicationRoot().

getAllUserResourceFoldersLocationsForWindowsStore()

void KoResourcePaths::getAllUserResourceFoldersLocationsForWindowsStore ( QString & standardLocation, QString & privateLocation )

static

getAllAppDataLocationsForWindowsStore Use this to get both private and general appdata folders which also considers user's choice of custom resource folder Used in GeneralTab in kis_dlg_preferences, and KisViewManager::openResourceDirectory().

Parameters

standardLocation	- location in standard AppData%
privateLocation	- location in private app AppData% location, only relevant for Windows Store

Returns

either both appdata locations, or just the custom resource folder

Definition at line 248 of file KoResourcePaths.cpp.

{
    standardLocation = "";
    privateLocation = "";
    QString resourcePath = QDir(KisResourceLocator::instance()->resourceLocationBase()).absolutePath();
#ifndef Q_OS_WIN
    // not Windows, no problem
    standardLocation = resourcePath;
    return;
#else
    if (!KisWindowsPackageUtils::isRunningInPackage()) {
        standardLocation = resourcePath; // Windows, but not Windows Store, so no problem
        return;
    }
 
    // running inside Windows Store
    const QDir resourceDir(resourcePath);
    QDir appDataGeneralDir = QDir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation));
    appDataGeneralDir.cdUp();
    const QString appDataGeneralDirPath = appDataGeneralDir.path();
    if (resourceDir.absolutePath().contains(appDataGeneralDirPath, Qt::CaseInsensitive)) {
        // resource folder location is inside appdata, so it can cause issues
        // from inside of Krita, we can't determine whether it uses genuine %AppData% or the private Windows Store one
        // so, half of the time, a custom folder inside %AppData% wouldn't work
        // we can't fix that, we can only inform users about it or prevent them from choosing such folder
        // in any case, here we need to return both folders: inside normal appdata and the private one
        // (note that this case also handles the default resource folder called "krita" inside the appdata)
 
 
        const QString folderName = QFileInfo(resourcePath).fileName();
 
        const QString privateAppData = KisWindowsPackageUtils::getPackageRoamingAppDataLocation();
        const QDir privateResourceDir(QDir::fromNativeSeparators(privateAppData) + '/' + folderName);
 
        standardLocation = resourcePath;
 
        if (privateResourceDir.exists()) {
            privateLocation = privateResourceDir.absolutePath();
        }
 
        return;
 
    } else {
        standardLocation = resourcePath; // custom folder not inside AppData, so no problem (hopefully)
        return;
    }
 
#endif
}

References KisWindowsPackageUtils::getPackageRoamingAppDataLocation(), KisResourceLocator::instance(), and KisWindowsPackageUtils::isRunningInPackage().

getAppDataLocation()

QString KoResourcePaths::getAppDataLocation ( )

static

Definition at line 219 of file KoResourcePaths.cpp.

{
    if (!s_overrideAppDataLocation.isEmpty()) {
        return s_overrideAppDataLocation;
    }
 
    QString path;
 
    KConfigGroup cfg(KSharedConfig::openConfig(), "");
    path = cfg.readEntry(KisResourceLocator::resourceLocationKey, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation));
 
    QFileInfo fi(path);
 
    // Check whether an existing location is writable
    if (fi.exists() && !fi.isWritable()) {
        path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
    }
    else if (!fi.exists()) {
        // Check whether a non-existing location can be created
        if (!QDir().mkpath(path)) {
            path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
        }
        QDir().rmpath(path);
    }
    return path;
 
 
}

References KisResourceLocator::resourceLocationKey, and s_overrideAppDataLocation.

getApplicationRoot()

QString KoResourcePaths::getApplicationRoot ( )

static

Definition at line 214 of file KoResourcePaths.cpp.

{
    return getInstallationPrefix();
}

locate()

QString KoResourcePaths::locate ( const QString & type, const QString & filename )

static

This function is just for convenience. It simply calls KoResourcePaths::findResource((type, filename).

Parameters

type	The type of the wanted resource, see KStandardDirs
filename	A relative filename of the resource

Returns

A full path to the filename specified in the second argument, or QString() if not found

Definition at line 336 of file KoResourcePaths.cpp.

{
    return cleanup(s_instance->locateInternal(type, filename));
}

locateInternal()

QString KoResourcePaths::locateInternal ( const QString & type, const QString & filename )

private

Definition at line 685 of file KoResourcePaths.cpp.

{
    QStringList aliases = d->aliases(type);
 
    QStringList locations;
    if (aliases.isEmpty()) {
        locations << QStandardPaths::locate(d->mapTypeToQStandardPaths(type), filename, QStandardPaths::LocateFile);
    }
 
    Q_FOREACH (const QString &alias, aliases) {
        locations << QStandardPaths::locate(d->mapTypeToQStandardPaths(type),
                                            (alias.endsWith('/') ? alias : alias + '/') + filename, QStandardPaths::LocateFile);
    }
    dbgResources << "locate: type" << type << "filename" << filename << "locations" << locations;
    if (locations.size() > 0) {
        return locations.first();
    }
    else {
        return "";
    }
}

References aliases(), d, and dbgResources.

locateLocal()

QString KoResourcePaths::locateLocal ( const QString & type, const QString & filename, bool createDir = false )

static

This function is much like locate. However it returns a filename suitable for writing to. No check is made if the specified filename actually exists. Missing directories are created. If filename is only a directory, without a specific file, filename must have a trailing slash.

Parameters

type	The type of the wanted resource, see KStandardDirs
filename	A relative filename of the resource

Returns

A full path to the filename specified in the second argument, or QString() if not found

Definition at line 341 of file KoResourcePaths.cpp.

{
    return cleanup(s_instance->locateLocalInternal(type, filename, createDir));
}

locateLocalInternal()

QString KoResourcePaths::locateLocalInternal ( const QString & type, const QString & filename, bool createDir = false )

private

Definition at line 707 of file KoResourcePaths.cpp.

{
    QString path = saveLocationInternal(type, "", createDir);
    dbgResources << "locateLocal: type" << type << "filename" << filename << "CreateDir" << createDir << "path" << path;
    return path + '/' + filename;
}

References dbgResources, and saveLocationInternal().

mapTypeToQStandardPaths()

QStandardPaths::StandardLocation KoResourcePaths::mapTypeToQStandardPaths ( const QString & type )

inline

Definition at line 182 of file KoResourcePaths.cpp.

    {
        if (type == "appdata") {
            return QStandardPaths::AppDataLocation;
        }
        else if (type == "data") {
            return QStandardPaths::AppDataLocation;
        }
        else if (type == "cache") {
            return QStandardPaths::CacheLocation;
        }
        else if (type == "locale") {
            return QStandardPaths::AppDataLocation;
        }
        else if (type == "genericdata") {
            return QStandardPaths::GenericDataLocation;
        }
        else {
            return QStandardPaths::AppDataLocation;
        }
    }

resourceDirsInternal()

QStringList KoResourcePaths::resourceDirsInternal ( const QString & type )

private

Definition at line 618 of file KoResourcePaths.cpp.

{
    QStringList resourceDirs;
    QStringList aliases = d->aliases(type);
 
    Q_FOREACH (const QString &alias, aliases) {
        QStringList aliasDirs;
 
        aliasDirs << QStandardPaths::locateAll(d->mapTypeToQStandardPaths(type), alias, QStandardPaths::LocateDirectory);
 
        aliasDirs << getInstallationPrefix() + "share/" + alias + "/"
                  << QStandardPaths::locateAll(d->mapTypeToQStandardPaths(type), alias, QStandardPaths::LocateDirectory);
        aliasDirs << getInstallationPrefix() + "share/krita/" + alias + "/"
                  << QStandardPaths::locateAll(d->mapTypeToQStandardPaths(type), alias, QStandardPaths::LocateDirectory);
 
        appendResources(&resourceDirs, aliasDirs, true);
    }
 
    dbgResources << "resourceDirs: type" << type << resourceDirs;
 
    return resourceDirs;
}

References aliases(), d, and dbgResources.

saveLocation()

QString KoResourcePaths::saveLocation ( const QString & type, const QString & suffix = QString(), bool create = true )

static

Finds a location to save files into for the given type in the user's home directory.

Parameters

type	The type of location to return.
suffix	A subdirectory name. Makes it easier for you to create subdirectories. You can't pass filenames here, you have to pass directory names only and add possible filename in that directory yourself. A directory name always has a trailing slash ('/').
create	If set, saveLocation() will create the directories needed (including those given by suffix).

Returns

A path where resources of the specified type should be saved, or QString() if the resource type is unknown.

Definition at line 331 of file KoResourcePaths.cpp.

{
    return QDir::cleanPath(s_instance->saveLocationInternal(type, suffix, create)) + '/';
}

saveLocationInternal()

QString KoResourcePaths::saveLocationInternal ( const QString & type, const QString & suffix = QString(), bool create = true )

private

Definition at line 641 of file KoResourcePaths.cpp.

{
    QString path;
 
    bool useStandardLocation = false;
    const QStringList aliases = d->aliases(type);
    const QStandardPaths::StandardLocation location = d->mapTypeToQStandardPaths(type);
 
    if (location == QStandardPaths::AppDataLocation) {
        KConfigGroup cfg(KSharedConfig::openConfig(), "");
        path = cfg.readEntry(KisResourceLocator::resourceLocationKey, "");
    }
 
    if (path.isEmpty()) {
        path = QStandardPaths::writableLocation(location);
        useStandardLocation = true;
    }
 
#ifndef Q_OS_ANDROID
    // on Android almost all config locations we save to are app specific,
    // and don't end with "krita".
    if (!path.endsWith("krita") && useStandardLocation) {
        path += "/krita";
    }
#endif
 
    if (!aliases.isEmpty()) {
        path += '/' + aliases.first();
    } else {
 
        if (!suffix.isEmpty()) {
            path += "/" + suffix;
        }
    }
 
    QDir d(path);
    if (!d.exists() && create) {
        d.mkpath(path);
    }
    dbgResources << "saveLocation: type" << type << "suffix" << suffix << "create" << create << "path" << path;
 
    return path;
}

References aliases(), d, dbgResources, and KisResourceLocator::resourceLocationKey.

Member Data Documentation

absolutes

QMap<QString, QStringList> KoResourcePaths::absolutes

Definition at line 158 of file KoResourcePaths.cpp.

absolutesMutex

QMutex KoResourcePaths::absolutesMutex

Definition at line 162 of file KoResourcePaths.cpp.

d

QScopedPointer<Private> KoResourcePaths::d

private

Definition at line 265 of file KoResourcePaths.h.

relatives

QMap<QString, QStringList> KoResourcePaths::relatives

Definition at line 159 of file KoResourcePaths.cpp.

relativesMutex

QMutex KoResourcePaths::relativesMutex

Definition at line 161 of file KoResourcePaths.cpp.

s_overrideAppDataLocation

QString KoResourcePaths::s_overrideAppDataLocation

static

getAppDataLocation Use this instead of QStandardPaths::AppDataLocation! The user can configure the location where resources and other user writable items are stored now.

Returns

the configured location for the appdata folder

Definition at line 62 of file KoResourcePaths.h.

---

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

• libs/resources/KoResourcePaths.cpp
• libs/resources/KoResourcePaths.h