qfileselector.cpp

Go to the documentation of this file.

// Copyright (C) 2013 BlackBerry Limited. All rights reserved.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qfileselector.h"
#include "qfileselector_p.h"
 
#include <QtCore/QFile>
#include <QtCore/QDir>
#include <QtCore/QMutex>
#include <QtCore/private/qlocking_p.h>
#include <QtCore/QUrl>
#include <QtCore/QFileInfo>
#include <QtCore/QLocale>
#include <QtCore/QDebug>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
//Environment variable to allow tooling full control of file selectors
static const char env_override[] = "QT_NO_BUILTIN_SELECTORS";
 
Q_GLOBAL_STATIC(QFileSelectorSharedData, sharedData);
Q_CONSTINIT static QBasicMutex sharedDataMutex;
 
QFileSelectorPrivate::QFileSelectorPrivate()
    : QObjectPrivate()
{
}
 
QFileSelector::QFileSelector(QObject *parent)
    : QObject(*(new QFileSelectorPrivate()), parent)
{
}
 
QFileSelector::~QFileSelector()
{
}
 
QString QFileSelector::select(const QString &filePath) const
{
    Q_D(const QFileSelector);
    return d->select(filePath);
}
 
static bool isLocalScheme(const QString &file)
{
    bool local = file == "qrc"_L1;
#ifdef Q_OS_ANDROID
    local |= file == "assets"_L1;
#endif
    return local;
}
 
QUrl QFileSelector::select(const QUrl &filePath) const
{
    Q_D(const QFileSelector);
    if (!isLocalScheme(filePath.scheme()) && !filePath.isLocalFile())
        return filePath;
    QUrl ret(filePath);
    if (isLocalScheme(filePath.scheme())) {
        auto scheme = ":"_L1;
#ifdef Q_OS_ANDROID
        // use other scheme because ":" means "qrc" here
        if (filePath.scheme() == "assets"_L1)
            scheme = "assets:"_L1;
#endif
 
        QString equivalentPath = scheme + filePath.path();
        QString selectedPath = d->select(equivalentPath);
        ret.setPath(selectedPath.remove(0, scheme.size()));
    } else {
        // we need to store the original query and fragment, since toLocalFile() will strip it off
        QString frag;
        if (ret.hasFragment())
            frag = ret.fragment();
        QString query;
        if (ret.hasQuery())
            query= ret.query();
        ret = QUrl::fromLocalFile(d->select(ret.toLocalFile()));
        if (!frag.isNull())
            ret.setFragment(frag);
        if (!query.isNull())
            ret.setQuery(query);
    }
    return ret;
}
 
QString QFileSelectorPrivate::selectionHelper(const QString &path, const QString &fileName,
                                              const QStringList &selectors, QChar indicator)
{
    /* selectionHelper does a depth-first search of possible selected files. Because there is strict
       selector ordering in the API, we can stop checking as soon as we find the file in a directory
       which does not contain any other valid selector directories.
    */
    Q_ASSERT(path.isEmpty() || path.endsWith(u'/'));
 
    for (const QString &s : selectors) {
        QString prospectiveBase = path;
        if (!indicator.isNull())
            prospectiveBase += indicator;
        prospectiveBase += s + u'/';
        QStringList remainingSelectors = selectors;
        remainingSelectors.removeAll(s);
        if (!QDir(prospectiveBase).exists())
            continue;
        QString prospectiveFile = selectionHelper(prospectiveBase, fileName, remainingSelectors, indicator);
        if (!prospectiveFile.isEmpty())
            return prospectiveFile;
    }
 
    // If we reach here there were no successful files found at a lower level in this branch, so we
    // should check this level as a potential result.
    if (!QFile::exists(path + fileName))
        return QString();
    return path + fileName;
}
 
QString QFileSelectorPrivate::select(const QString &filePath) const
{
    Q_Q(const QFileSelector);
    QFileInfo fi(filePath);
 
    QString pathString;
    if (auto path = fi.path(); !path.isEmpty())
        pathString = path.endsWith(u'/') ? path : path + u'/';
    QString ret = selectionHelper(pathString,
            fi.fileName(), q->allSelectors());
 
    if (!ret.isEmpty())
        return ret;
    return filePath;
}
 
QStringList QFileSelector::extraSelectors() const
{
    Q_D(const QFileSelector);
    return d->extras;
}
 
void QFileSelector::setExtraSelectors(const QStringList &list)
{
    Q_D(QFileSelector);
    d->extras = list;
}
 
QStringList QFileSelector::allSelectors() const
{
    Q_D(const QFileSelector);
    const auto locker = qt_scoped_lock(sharedDataMutex);
    QFileSelectorPrivate::updateSelectors();
    return d->extras + sharedData->staticSelectors;
}
 
void QFileSelectorPrivate::updateSelectors()
{
    if (!sharedData->staticSelectors.isEmpty())
        return; //Already loaded
 
    QLatin1Char pathSep(',');
    QStringList envSelectors = QString::fromLatin1(qgetenv("QT_FILE_SELECTORS"))
                                .split(pathSep, Qt::SkipEmptyParts);
    if (envSelectors.size())
        sharedData->staticSelectors << envSelectors;
 
    if (!qEnvironmentVariableIsEmpty(env_override))
        return;
 
    sharedData->staticSelectors << sharedData->preloadedStatics; //Potential for static selectors from other modules
 
    // TODO: Update on locale changed?
    sharedData->staticSelectors << QLocale().name();
 
    sharedData->staticSelectors << platformSelectors();
}
 
QStringList QFileSelectorPrivate::platformSelectors()
{
    // similar, but not identical to QSysInfo::osType
    QStringList ret;
#if defined(Q_OS_WIN)
    ret << QStringLiteral("windows");
    ret << QSysInfo::kernelType();  // "winnt"
#elif defined(Q_OS_UNIX)
    ret << QStringLiteral("unix");
#  if !defined(Q_OS_ANDROID) && !defined(Q_OS_QNX)
    // we don't want "linux" for Android or two instances of "qnx" for QNX
    ret << QSysInfo::kernelType();
#  endif
    QString productName = QSysInfo::productType();
    if (productName != "unknown"_L1)
        ret << productName; // "opensuse", "fedora", "osx", "ios", "android"
#endif
    return ret;
}
 
void QFileSelectorPrivate::addStatics(const QStringList &statics)
{
    const auto locker = qt_scoped_lock(sharedDataMutex);
    sharedData->preloadedStatics << statics;
    sharedData->staticSelectors.clear();
}
 
QT_END_NAMESPACE
 
#include "moc_qfileselector.cpp"