qmimetype.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2015 Klaralvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author David Faure <david.faure@kdab.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qmimetype.h"
 
#include "qmimetype_p.h"
#include "qmimedatabase_p.h"
#include "qmimeprovider_p.h"
 
#include "qmimeglobpattern_p.h"
 
#include <QtCore/QDebug>
#include <QtCore/QLocale>
#include <QtCore/QHashFunctions>
 
#include <memory>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
QMimeTypePrivate::QMimeTypePrivate()
    : loaded(false), fromCache(false)
{}
 
QMimeTypePrivate::QMimeTypePrivate(const QMimeType &other)
      : loaded(other.d->loaded),
        name(other.d->name),
        localeComments(other.d->localeComments),
        genericIconName(other.d->genericIconName),
        iconName(other.d->iconName),
        globPatterns(other.d->globPatterns)
{}
 
void QMimeTypePrivate::clear()
{
    name.clear();
    localeComments.clear();
    genericIconName.clear();
    iconName.clear();
    globPatterns.clear();
}
 
void QMimeTypePrivate::addGlobPattern(const QString &pattern)
{
    globPatterns.append(pattern);
}
 
QMimeType::QMimeType() :
        d(new QMimeTypePrivate())
{
}
 
QMimeType::QMimeType(const QMimeType &other) :
        d(other.d)
{
}
 
QMimeType &QMimeType::operator=(const QMimeType &other)
{
    if (d != other.d)
        d = other.d;
    return *this;
}
 
QMimeType::QMimeType(const QMimeTypePrivate &dd) :
        d(new QMimeTypePrivate(dd))
{
}
 
QMimeType::~QMimeType()
{
}
 
bool QMimeType::operator==(const QMimeType &other) const
{
    return d == other.d || d->name == other.d->name;
}
 
size_t qHash(const QMimeType &key, size_t seed) noexcept
{
    return qHash(key.d->name, seed);
}
 
bool QMimeType::isValid() const
{
    return !d->name.isEmpty();
}
 
bool QMimeType::isDefault() const
{
    return d->name == QMimeDatabasePrivate::instance()->defaultMimeType();
}
 
QString QMimeType::name() const
{
    return d->name;
}
 
QString QMimeType::comment() const
{
    QMimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<QMimeTypePrivate&>(*d));
 
    QStringList languageList;
    languageList << QLocale().name();
    languageList << QLocale().uiLanguages();
    languageList << u"default"_s; // use the default locale if possible.
    for (const QString &language : std::as_const(languageList)) {
        const QString lang = language == "C"_L1 ? u"en_US"_s : language;
        const QString comm = d->localeComments.value(lang);
        if (!comm.isEmpty())
            return comm;
        const qsizetype pos = lang.indexOf(u'_');
        if (pos != -1) {
            // "pt_BR" not found? try just "pt"
            const QString shortLang = lang.left(pos);
            const QString commShort = d->localeComments.value(shortLang);
            if (!commShort.isEmpty())
                return commShort;
        }
    }
 
    // Use the mimetype name as fallback
    return d->name;
}
 
QString QMimeType::genericIconName() const
{
    QMimeDatabasePrivate::instance()->loadGenericIcon(const_cast<QMimeTypePrivate&>(*d));
    if (d->genericIconName.isEmpty()) {
        // From the spec:
        // If the generic icon name is empty (not specified by the mimetype definition)
        // then the mimetype is used to generate the generic icon by using the top-level
        // media type (e.g.  "video" in "video/ogg") and appending "-x-generic"
        // (i.e. "video-x-generic" in the previous example).
        const QString group = name();
        QStringView groupRef(group);
        const qsizetype slashindex = groupRef.indexOf(u'/');
        if (slashindex != -1)
            groupRef = groupRef.left(slashindex);
        return groupRef + "-x-generic"_L1;
    }
    return d->genericIconName;
}
 
static QString make_default_icon_name_from_mimetype_name(QString iconName)
{
    const qsizetype slashindex = iconName.indexOf(u'/');
    if (slashindex != -1)
        iconName[slashindex] = u'-';
    return iconName;
}
 
QString QMimeType::iconName() const
{
    QMimeDatabasePrivate::instance()->loadIcon(const_cast<QMimeTypePrivate&>(*d));
    if (d->iconName.isEmpty()) {
        return make_default_icon_name_from_mimetype_name(name());
    }
    return d->iconName;
}
 
QStringList QMimeType::globPatterns() const
{
    QMimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<QMimeTypePrivate&>(*d));
    return d->globPatterns;
}
 
QStringList QMimeType::parentMimeTypes() const
{
    return QMimeDatabasePrivate::instance()->mimeParents(d->name);
}
 
static void collectParentMimeTypes(const QString &mime, QStringList &allParents)
{
    const QStringList parents = QMimeDatabasePrivate::instance()->mimeParents(mime);
    for (const QString &parent : parents) {
        // I would use QSet, but since order matters I better not
        if (!allParents.contains(parent))
            allParents.append(parent);
    }
    // We want a breadth-first search, so that the least-specific parent (octet-stream) is last
    // This means iterating twice, unfortunately.
    for (const QString &parent : parents)
        collectParentMimeTypes(parent, allParents);
}
 
QStringList QMimeType::allAncestors() const
{
    QStringList allParents;
    collectParentMimeTypes(d->name, allParents);
    return allParents;
}
 
QStringList QMimeType::aliases() const
{
    return QMimeDatabasePrivate::instance()->listAliases(d->name);
}
 
QStringList QMimeType::suffixes() const
{
    QMimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<QMimeTypePrivate&>(*d));
 
    QStringList result;
    for (const QString &pattern : std::as_const(d->globPatterns)) {
        // Not a simple suffix if it looks like: README or *. or *.* or *.JP*G or *.JP?
        if (pattern.startsWith("*."_L1) &&
            pattern.size() > 2 &&
            pattern.indexOf(u'*', 2) < 0 && pattern.indexOf(u'?', 2) < 0) {
            const QString suffix = pattern.mid(2);
            result.append(suffix);
        }
    }
 
    return result;
}
 
QString QMimeType::preferredSuffix() const
{
    if (isDefault()) // workaround for unwanted *.bin suffix for octet-stream, https://bugs.freedesktop.org/show_bug.cgi?id=101667, fixed upstream in 1.10
        return QString();
    const QStringList suffixList = suffixes();
    return suffixList.isEmpty() ? QString() : suffixList.at(0);
}
 
QString QMimeType::filterString() const
{
    QMimeDatabasePrivate::instance()->loadMimeTypePrivate(const_cast<QMimeTypePrivate&>(*d));
    QString filter;
 
    if (!d->globPatterns.empty()) {
        filter += comment() + " ("_L1;
        for (int i = 0; i < d->globPatterns.size(); ++i) {
            if (i != 0)
                filter += u' ';
            filter += d->globPatterns.at(i);
        }
        filter +=  u')';
    }
 
    return filter;
}
 
bool QMimeType::inherits(const QString &mimeTypeName) const
{
    if (d->name == mimeTypeName)
        return true;
    return QMimeDatabasePrivate::instance()->mimeInherits(d->name, mimeTypeName);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QMimeType &mime)
{
    QDebugStateSaver saver(debug);
    if (!mime.isValid()) {
        debug.nospace() << "QMimeType(invalid)";
    } else {
        debug.nospace() << "QMimeType(" << mime.name() << ")";
    }
    return debug;
}
#endif
 
QT_END_NAMESPACE
 
#include "moc_qmimetype.cpp"