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 <QtCore/QDebug>
#include <QtCore/QLocale>
#include <QtCore/QHashFunctions>
 
#include <memory>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
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 comparesEqual(const QMimeType &lhs, const QMimeType &rhs) noexcept
{
    return lhs.d == rhs.d || lhs.d->name == rhs.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
{
    const auto localeComments = QMimeDatabasePrivate::instance()->localeComments(d->name);
 
    QStringList languageList = QLocale().uiLanguages(QLocale::TagSeparator::Underscore);
    qsizetype defaultIndex = languageList.indexOf(u"en_US"_s);
 
    // Include the default locale as fall-back.
    if (defaultIndex >= 0) {
        // en_US is generally the default, and may be omitted from the
        // overtly-named locales in the MIME type's data (QTBUG-105007).
        ++defaultIndex; // Skip over en_US.
        // That's typically followed by en_Latn_US and en (in that order):
        if (defaultIndex < languageList.size() && languageList.at(defaultIndex) == u"en_Latn_US")
            ++defaultIndex;
        if (defaultIndex < languageList.size() && languageList.at(defaultIndex) == u"en")
            ++defaultIndex;
    } else {
        // Absent en-US, just append it:
        defaultIndex = languageList.size();
    }
    languageList.insert(defaultIndex, u"default"_s);
 
    for (const QString &language : std::as_const(languageList)) {
        const QString lang = language == "C"_L1 ? u"en_US"_s : language;
        QString comm = localeComments.value(lang);
        if (!comm.isEmpty())
            return comm;
        const qsizetype cut = lang.indexOf(u'_');
        // If "de_CH" is missing, check for "de" (and similar):
        if (cut != -1) {
            comm = localeComments.value(lang.left(cut));
            if (!comm.isEmpty())
                return comm;
        }
    }
 
    // Use the mimetype name as fallback
    return d->name;
}
 
QString QMimeType::genericIconName() const
{
    QString genericIconName = QMimeDatabasePrivate::instance()->genericIcon(d->name);
    if (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 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
{
    QString iconName = QMimeDatabasePrivate::instance()->icon(d->name);
    if (iconName.isEmpty()) {
        return make_default_icon_name_from_mimetype_name(name());
    }
    return iconName;
}
 
QStringList QMimeType::globPatterns() const
{
    return QMimeDatabasePrivate::instance()->globPatterns(d->name);
}
 
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);
    QStringList newParents;
    for (const QString &parent : parents) {
        // I would use QSet, but since order matters I better not
        if (!allParents.contains(parent)) {
            allParents.append(parent);
            newParents.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 : newParents)
        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
{
    const QStringList patterns = globPatterns();
 
    QStringList result;
    result.reserve(patterns.size());
    for (const QString &pattern : patterns) {
        // 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
{
    const QStringList patterns = globPatterns();
    QString filter;
 
    if (!patterns.isEmpty()) {
        filter = comment() + " ("_L1 + patterns.join(u' ') + 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"