qmimedata.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qmimedata.h"
 
#include "private/qobject_p.h"
#include "qurl.h"
#include "qstringlist.h"
#include "qstringconverter.h"
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
static inline QString textUriListLiteral() { return QStringLiteral("text/uri-list"); }
static inline QString textHtmlLiteral() { return QStringLiteral("text/html"); }
static inline QString textPlainLiteral() { return QStringLiteral("text/plain"); }
static inline QString textPlainUtf8Literal() { return QStringLiteral("text/plain;charset=utf-8"); }
static inline QString applicationXColorLiteral() { return QStringLiteral("application/x-color"); }
static inline QString applicationXQtImageLiteral() { return QStringLiteral("application/x-qt-image"); }
 
struct QMimeDataStruct
{
    QString format;
    QVariant data;
};
Q_DECLARE_TYPEINFO(QMimeDataStruct, Q_RELOCATABLE_TYPE);
 
class QMimeDataPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QMimeData)
public:
    void removeData(const QString &format);
    void setData(const QString &format, const QVariant &data);
    QVariant getData(const QString &format) const;
 
    QVariant retrieveTypedData(const QString &format, QMetaType type) const;
 
    std::vector<QMimeDataStruct>::iterator find(const QString &format) noexcept {
        const auto formatEquals = [](const QString &format) {
            return [&format](const QMimeDataStruct &s) { return s.format == format; };
        };
        return std::find_if(dataList.begin(), dataList.end(), formatEquals(format));
    }
 
    std::vector<QMimeDataStruct>::const_iterator find(const QString &format) const noexcept {
        return const_cast<QMimeDataPrivate*>(this)->find(format);
    }
 
    std::vector<QMimeDataStruct> dataList;
};
 
void QMimeDataPrivate::removeData(const QString &format)
{
    const auto it = find(format);
    if (it != dataList.end())
        dataList.erase(it);
}
 
void QMimeDataPrivate::setData(const QString &format, const QVariant &data)
{
    const auto it = find(format);
    if (it == dataList.end())
        dataList.push_back({format, data});
    else
        it->data = data;
}
 
 
QVariant QMimeDataPrivate::getData(const QString &format) const
{
    const auto it = find(format);
    if (it == dataList.cend())
        return {};
    else
        return it->data;
}
 
static QList<QVariant> dataToUrls(QByteArrayView text)
{
    QList<QVariant> list;
    qsizetype newLineIndex = -1;
    qsizetype from = 0;
    const char *begin = text.data();
    while ((newLineIndex = text.indexOf('\n', from)) != -1) {
        QByteArrayView bav(begin + from, begin + newLineIndex);
        bav = bav.trimmed();
        if (!bav.isEmpty())
            list.push_back(QUrl::fromEncoded(bav));
        from = newLineIndex + 1;
        if (from >= text.size())
            break;
    }
    return list;
}
 
QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QMetaType type) const
{
    Q_Q(const QMimeData);
    int typeId = type.id();
 
    QVariant data = q->retrieveData(format, type);
 
    // Text data requested: fallback to URL data if available
    if (format == "text/plain"_L1 && !data.isValid()) {
        data = retrieveTypedData(textUriListLiteral(), QMetaType(QMetaType::QVariantList));
        if (data.metaType().id() == QMetaType::QUrl) {
            data = QVariant(data.toUrl().toDisplayString());
        } else if (data.metaType().id() == QMetaType::QVariantList) {
            QString text;
            int numUrls = 0;
            const QList<QVariant> list = data.toList();
            for (int i = 0; i < list.size(); ++i) {
                if (list.at(i).metaType().id() == QMetaType::QUrl) {
                    text += list.at(i).toUrl().toDisplayString() + u'\n';
                    ++numUrls;
                }
            }
            if (numUrls == 1)
                text.chop(1); // no final '\n' if there's only one URL
            data = QVariant(text);
        }
    }
 
    if (data.metaType() == type || !data.isValid())
        return data;
 
    // provide more conversion possibilities than just what QVariant provides
 
    // URLs can be lists as well...
    if ((typeId == QMetaType::QUrl && data.metaType().id() == QMetaType::QVariantList)
        || (typeId == QMetaType::QVariantList && data.metaType().id() == QMetaType::QUrl))
        return data;
 
    // images and pixmaps are interchangeable
    if ((typeId == QMetaType::QPixmap && data.metaType().id() == QMetaType::QImage)
        || (typeId == QMetaType::QImage && data.metaType().id() == QMetaType::QPixmap))
        return data;
 
    if (data.metaType().id() == QMetaType::QByteArray) {
        // see if we can convert to the requested type
        switch (typeId) {
        case QMetaType::QString: {
            const QByteArray ba = data.toByteArray();
            if (ba.isNull())
                return QVariant();
            if (format == "text/html"_L1) {
                QStringDecoder decoder = QStringDecoder::decoderForHtml(ba);
                if (decoder.isValid()) {
                    return QString(decoder(ba));
                }
                // fall back to utf8
            }
            return QString::fromUtf8(ba);
        }
        case QMetaType::QColor: {
            QVariant newData = data;
            newData.convert(QMetaType(QMetaType::QColor));
            return newData;
        }
        case QMetaType::QVariantList: {
            if (format != "text/uri-list"_L1)
                break;
            Q_FALLTHROUGH();
        }
        case QMetaType::QUrl: {
            auto bav = data.view<QByteArrayView>();
            // Qt 3.x will send text/uri-list with a trailing
            // null-terminator (that is *not* sent for any other
            // text/* mime-type), so chop it off
            if (bav.endsWith('\0'))
                bav.chop(1);
            return dataToUrls(bav);
        }
        default:
            break;
        }
 
    } else if (typeId == QMetaType::QByteArray) {
 
        // try to convert to bytearray
        switch (data.metaType().id()) {
        case QMetaType::QByteArray:
        case QMetaType::QColor:
            return data.toByteArray();
        case QMetaType::QString:
            return data.toString().toUtf8();
        case QMetaType::QUrl:
            return data.toUrl().toEncoded();
        case QMetaType::QVariantList: {
            // has to be list of URLs
            QByteArray result;
            QList<QVariant> list = data.toList();
            for (int i = 0; i < list.size(); ++i) {
                if (list.at(i).metaType().id() == QMetaType::QUrl) {
                    result += list.at(i).toUrl().toEncoded();
                    result += "\r\n";
                }
            }
            if (!result.isEmpty())
                return result;
            break;
        }
        default:
            break;
        }
    }
    return data;
}
 
QMimeData::QMimeData()
    : QObject(*new QMimeDataPrivate, nullptr)
{
}
 
QMimeData::~QMimeData()
{
}
 
QList<QUrl> QMimeData::urls() const
{
    Q_D(const QMimeData);
    QVariant data = d->retrieveTypedData(textUriListLiteral(), QMetaType(QMetaType::QVariantList));
    QList<QUrl> urls;
    if (data.metaType().id() == QMetaType::QUrl)
        urls.append(data.toUrl());
    else if (data.metaType().id() == QMetaType::QVariantList) {
        QList<QVariant> list = data.toList();
        for (int i = 0; i < list.size(); ++i) {
            if (list.at(i).metaType().id() == QMetaType::QUrl)
                urls.append(list.at(i).toUrl());
        }
    }
    return urls;
}
 
void QMimeData::setUrls(const QList<QUrl> &urls)
{
    Q_D(QMimeData);
    d->setData(textUriListLiteral(), QList<QVariant>(urls.cbegin(), urls.cend()));
}
 
bool QMimeData::hasUrls() const
{
    return hasFormat(textUriListLiteral());
}
 
 
QString QMimeData::text() const
{
    Q_D(const QMimeData);
    QVariant utf8Text = d->retrieveTypedData(textPlainUtf8Literal(), QMetaType(QMetaType::QString));
    if (!utf8Text.isNull())
        return utf8Text.toString();
 
    QVariant data = d->retrieveTypedData(textPlainLiteral(), QMetaType(QMetaType::QString));
    return data.toString();
}
 
void QMimeData::setText(const QString &text)
{
    Q_D(QMimeData);
    d->setData(textPlainLiteral(), text);
}
 
bool QMimeData::hasText() const
{
    return hasFormat(textPlainLiteral()) || hasUrls();
}
 
QString QMimeData::html() const
{
    Q_D(const QMimeData);
    QVariant data = d->retrieveTypedData(textHtmlLiteral(), QMetaType(QMetaType::QString));
    return data.toString();
}
 
void QMimeData::setHtml(const QString &html)
{
    Q_D(QMimeData);
    d->setData(textHtmlLiteral(), html);
}
 
bool QMimeData::hasHtml() const
{
    return hasFormat(textHtmlLiteral());
}
 
QVariant QMimeData::imageData() const
{
    Q_D(const QMimeData);
    return d->retrieveTypedData(applicationXQtImageLiteral(), QMetaType(QMetaType::QImage));
}
 
void QMimeData::setImageData(const QVariant &image)
{
    Q_D(QMimeData);
    d->setData(applicationXQtImageLiteral(), image);
}
 
bool QMimeData::hasImage() const
{
    return hasFormat(applicationXQtImageLiteral());
}
 
QVariant QMimeData::colorData() const
{
    Q_D(const QMimeData);
    return d->retrieveTypedData(applicationXColorLiteral(), QMetaType(QMetaType::QColor));
}
 
void QMimeData::setColorData(const QVariant &color)
{
    Q_D(QMimeData);
    d->setData(applicationXColorLiteral(), color);
}
 
 
bool QMimeData::hasColor() const
{
    return hasFormat(applicationXColorLiteral());
}
 
QByteArray QMimeData::data(const QString &mimeType) const
{
    Q_D(const QMimeData);
    QVariant data = d->retrieveTypedData(mimeType, QMetaType(QMetaType::QByteArray));
    return data.toByteArray();
}
 
void QMimeData::setData(const QString &mimeType, const QByteArray &data)
{
    Q_D(QMimeData);
 
    if (mimeType == "text/uri-list"_L1) {
        QByteArray ba = data;
        if (ba.endsWith('\0'))
            ba.chop(1);
        d->setData(mimeType, dataToUrls(ba));
    } else {
        d->setData(mimeType, QVariant(data));
    }
}
 
bool QMimeData::hasFormat(const QString &mimeType) const
{
    return formats().contains(mimeType);
}
 
QStringList QMimeData::formats() const
{
    Q_D(const QMimeData);
    QStringList list;
    list.reserve(static_cast<int>(d->dataList.size()));
    for (auto &e : d->dataList)
        list += e.format;
    return list;
}
 
QVariant QMimeData::retrieveData(const QString &mimeType, QMetaType type) const
{
    Q_UNUSED(type);
    Q_D(const QMimeData);
    return d->getData(mimeType);
}
 
void QMimeData::clear()
{
    Q_D(QMimeData);
    d->dataList.clear();
}
 
void QMimeData::removeFormat(const QString &mimeType)
{
    Q_D(QMimeData);
    d->removeData(mimeType);
}
 
QT_END_NAMESPACE
 
#include "moc_qmimedata.cpp"