1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup API of QMimeData

Browse Source 
Do not use QVariant::Type anymore, instead use QMetaType

For some reason, this pushed the qvariant autotest over the limit where
MSVC requires the /bigobj flag, so add that one.

[ChangeLog][QtCore][QMimeData] The signature of the virtual retrieveData()
function has changed and now takes a QMetaType instead of a QVariant::Type.

Change-Id: Ib46773bd731ee2177b1ef74d8162d744be7017ef
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
This commit is contained in:
Lars Knoll 2020-09-10 19:51:38 +02:00
parent cf015cd08b
commit 848927b688
25 changed files with 103 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
src/corelib/kernel/qmimedata.cpp
View File

@ -68,7 +68,7 @@ public:
void setData(const QString &format, const QVariant &data); void setData(const QString &format, const QVariant &data);
QVariant getData(const QString &format) const; QVariant getData(const QString &format) const;
QVariant retrieveTypedData(const QString &format, QMetaType::Type type) const; QVariant retrieveTypedData(const QString &format, QMetaType type) const;
std::vector<QMimeDataStruct>::iterator find(const QString &format) noexcept { std::vector<QMimeDataStruct>::iterator find(const QString &format) noexcept {
const auto formatEquals = [](const QString &format) { const auto formatEquals = [](const QString &format) {
@ -110,23 +110,24 @@ QVariant QMimeDataPrivate::getData(const QString &format) const
return it->data; return it->data;
} }
QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QMetaType::Type type) const QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QMetaType type) const
{ {
Q_Q(const QMimeData); Q_Q(const QMimeData);
int typeId = type.id();
QVariant data = q->retrieveData(format, QVariant::Type(type)); QVariant data = q->retrieveData(format, type);
// Text data requested: fallback to URL data if available // Text data requested: fallback to URL data if available
if (format == QLatin1String("text/plain") && !data.isValid()) { if (format == QLatin1String("text/plain") && !data.isValid()) {
data = retrieveTypedData(textUriListLiteral(), QMetaType::QVariantList); data = retrieveTypedData(textUriListLiteral(), QMetaType(QMetaType::QVariantList));
if (data.userType() == QMetaType::QUrl) { if (data.metaType().id() == QMetaType::QUrl) {
data = QVariant(data.toUrl().toDisplayString()); data = QVariant(data.toUrl().toDisplayString());
} else if (data.userType() == QMetaType::QVariantList) { } else if (data.metaType().id() == QMetaType::QVariantList) {
QString text; QString text;
int numUrls = 0; int numUrls = 0;
const QList<QVariant> list = data.toList(); const QList<QVariant> list = data.toList();
for (int i = 0; i < list.size(); ++i) { for (int i = 0; i < list.size(); ++i) {
if (list.at(i).userType() == QMetaType::QUrl) { if (list.at(i).metaType().id() == QMetaType::QUrl) {
text += list.at(i).toUrl().toDisplayString() + QLatin1Char('\n'); text += list.at(i).toUrl().toDisplayString() + QLatin1Char('\n');
++numUrls; ++numUrls;
} }
@ -137,24 +138,24 @@ QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QMetaType::T
} }
} }
if (data.userType() == type || !data.isValid()) if (data.metaType() == type || !data.isValid())
return data; return data;
// provide more conversion possiblities than just what QVariant provides // provide more conversion possiblities than just what QVariant provides
// URLs can be lists as well... // URLs can be lists as well...
if ((type == QMetaType::QUrl && data.userType() == QMetaType::QVariantList) if ((typeId == QMetaType::QUrl && data.metaType().id() == QMetaType::QVariantList)
|| (type == QMetaType::QVariantList && data.userType() == QMetaType::QUrl)) || (typeId == QMetaType::QVariantList && data.metaType().id() == QMetaType::QUrl))
return data; return data;
// images and pixmaps are interchangeable // images and pixmaps are interchangeable
if ((type == QMetaType::QPixmap && data.userType() == QMetaType::QImage) if ((typeId == QMetaType::QPixmap && data.metaType().id() == QMetaType::QImage)
|| (type == QMetaType::QImage && data.userType() == QMetaType::QPixmap)) || (typeId == QMetaType::QImage && data.metaType().id() == QMetaType::QPixmap))
return data; return data;
if (data.userType() == QMetaType::QByteArray) { if (data.metaType().id() == QMetaType::QByteArray) {
// see if we can convert to the requested type // see if we can convert to the requested type
switch(type) { switch (typeId) {
case QMetaType::QString: { case QMetaType::QString: {
const QByteArray ba = data.toByteArray(); const QByteArray ba = data.toByteArray();
if (format == QLatin1String("text/html")) { if (format == QLatin1String("text/html")) {
@ -200,10 +201,10 @@ QT_WARNING_POP
break; break;
} }
} else if (type == QMetaType::QByteArray) { } else if (typeId == QMetaType::QByteArray) {
// try to convert to bytearray // try to convert to bytearray
switch (data.userType()) { switch (data.metaType().id()) {
case QMetaType::QByteArray: case QMetaType::QByteArray:
case QMetaType::QColor: case QMetaType::QColor:
return data.toByteArray(); return data.toByteArray();
@ -216,7 +217,7 @@ QT_WARNING_POP
QByteArray result; QByteArray result;
QList<QVariant> list = data.toList(); QList<QVariant> list = data.toList();
for (int i = 0; i < list.size(); ++i) { for (int i = 0; i < list.size(); ++i) {
if (list.at(i).userType() == QMetaType::QUrl) { if (list.at(i).metaType().id() == QMetaType::QUrl) {
result += list.at(i).toUrl().toEncoded(); result += list.at(i).toUrl().toEncoded();
result += "\r\n"; result += "\r\n";
} }
@ -347,14 +348,14 @@ QMimeData::~QMimeData()
QList<QUrl> QMimeData::urls() const QList<QUrl> QMimeData::urls() const
{ {
Q_D(const QMimeData); Q_D(const QMimeData);
QVariant data = d->retrieveTypedData(textUriListLiteral(), QMetaType::QVariantList); QVariant data = d->retrieveTypedData(textUriListLiteral(), QMetaType(QMetaType::QVariantList));
QList<QUrl> urls; QList<QUrl> urls;
if (data.userType() == QMetaType::QUrl) if (data.metaType().id() == QMetaType::QUrl)
urls.append(data.toUrl()); urls.append(data.toUrl());
else if (data.userType() == QMetaType::QVariantList) { else if (data.metaType().id() == QMetaType::QVariantList) {
QList<QVariant> list = data.toList(); QList<QVariant> list = data.toList();
for (int i = 0; i < list.size(); ++i) { for (int i = 0; i < list.size(); ++i) {
if (list.at(i).userType() == QMetaType::QUrl) if (list.at(i).metaType().id() == QMetaType::QUrl)
urls.append(list.at(i).toUrl()); urls.append(list.at(i).toUrl());
} }
} }
@ -407,11 +408,11 @@ bool QMimeData::hasUrls() const
QString QMimeData::text() const QString QMimeData::text() const
{ {
Q_D(const QMimeData); Q_D(const QMimeData);
QVariant utf8Text = d->retrieveTypedData(textPlainUtf8Literal(), QMetaType::QString); QVariant utf8Text = d->retrieveTypedData(textPlainUtf8Literal(), QMetaType(QMetaType::QString));
if (!utf8Text.isNull()) if (!utf8Text.isNull())
return utf8Text.toString(); return utf8Text.toString();
QVariant data = d->retrieveTypedData(textPlainLiteral(), QMetaType::QString); QVariant data = d->retrieveTypedData(textPlainLiteral(), QMetaType(QMetaType::QString));
return data.toString(); return data.toString();
} }
@ -447,7 +448,7 @@ bool QMimeData::hasText() const
QString QMimeData::html() const QString QMimeData::html() const
{ {
Q_D(const QMimeData); Q_D(const QMimeData);
QVariant data = d->retrieveTypedData(textHtmlLiteral(), QMetaType::QString); QVariant data = d->retrieveTypedData(textHtmlLiteral(), QMetaType(QMetaType::QString));
return data.toString(); return data.toString();
} }
@ -489,7 +490,7 @@ bool QMimeData::hasHtml() const
QVariant QMimeData::imageData() const QVariant QMimeData::imageData() const
{ {
Q_D(const QMimeData); Q_D(const QMimeData);
return d->retrieveTypedData(applicationXQtImageLiteral(), QMetaType::QImage); return d->retrieveTypedData(applicationXQtImageLiteral(), QMetaType(QMetaType::QImage));
} }
/*! /*!
@ -536,7 +537,7 @@ bool QMimeData::hasImage() const
QVariant QMimeData::colorData() const QVariant QMimeData::colorData() const
{ {
Q_D(const QMimeData); Q_D(const QMimeData);
return d->retrieveTypedData(applicationXColorLiteral(), QMetaType::QColor); return d->retrieveTypedData(applicationXColorLiteral(), QMetaType(QMetaType::QColor));
} }
/*! /*!
@ -571,7 +572,7 @@ bool QMimeData::hasColor() const
QByteArray QMimeData::data(const QString &mimeType) const QByteArray QMimeData::data(const QString &mimeType) const
{ {
Q_D(const QMimeData); Q_D(const QMimeData);
QVariant data = d->retrieveTypedData(mimeType, QMetaType::QByteArray); QVariant data = d->retrieveTypedData(mimeType, QMetaType(QMetaType::QByteArray));
return data.toByteArray(); return data.toByteArray();
} }
@ -661,7 +662,7 @@ QStringList QMimeData::formats() const
\sa data() \sa data()
*/ */
QVariant QMimeData::retrieveData(const QString &mimeType, QVariant::Type type) const QVariant QMimeData::retrieveData(const QString &mimeType, QMetaType type) const
{ {
Q_UNUSED(type); Q_UNUSED(type);
Q_D(const QMimeData); Q_D(const QMimeData);

3
src/corelib/kernel/qmimedata.h
View File

@ -85,8 +85,7 @@ public:
void clear(); void clear();
protected: protected:
virtual QVariant retrieveData(const QString &mimetype, virtual QVariant retrieveData(const QString &mimetype, QMetaType preferredType) const;
QVariant::Type preferredType) const;
private: private:
Q_DISABLE_COPY(QMimeData) Q_DISABLE_COPY(QMimeData)
Q_DECLARE_PRIVATE(QMimeData) Q_DECLARE_PRIVATE(QMimeData)

14
src/gui/kernel/qinternalmimedata.cpp
View File

@ -108,27 +108,27 @@ QStringList QInternalMimeData::formats() const
return realFormats; return realFormats;
} }
QVariant QInternalMimeData::retrieveData(const QString &mimeType, QVariant::Type type) const QVariant QInternalMimeData::retrieveData(const QString &mimeType, QMetaType type) const
{ {
QVariant data = retrieveData_sys(mimeType, type); QVariant data = retrieveData_sys(mimeType, type);
if (mimeType == QLatin1String("application/x-qt-image")) { if (mimeType == QLatin1String("application/x-qt-image")) {
if (data.isNull() || (data.userType() == QMetaType::QByteArray && data.toByteArray().isEmpty())) { if (data.isNull() || (data.metaType().id() == QMetaType::QByteArray && data.toByteArray().isEmpty())) {
// try to find an image // try to find an image
QStringList imageFormats = imageReadMimeFormats(); QStringList imageFormats = imageReadMimeFormats();
for (int i = 0; i < imageFormats.size(); ++i) { for (int i = 0; i < imageFormats.size(); ++i) {
data = retrieveData_sys(imageFormats.at(i), type); data = retrieveData_sys(imageFormats.at(i), type);
if (data.isNull() || (data.userType() == QMetaType::QByteArray && data.toByteArray().isEmpty())) if (data.isNull() || (data.metaType().id() == QMetaType::QByteArray && data.toByteArray().isEmpty()))
continue; continue;
break; break;
} }
} }
int typeId = type; int typeId = type.id();
// we wanted some image type, but all we got was a byte array. Convert it to an image. // we wanted some image type, but all we got was a byte array. Convert it to an image.
if (data.userType() == QMetaType::QByteArray if (data.metaType().id() == QMetaType::QByteArray
&& (typeId == QMetaType::QImage || typeId == QMetaType::QPixmap || typeId == QMetaType::QBitmap)) && (typeId == QMetaType::QImage || typeId == QMetaType::QPixmap || typeId == QMetaType::QBitmap))
data = QImage::fromData(data.toByteArray()); data = QImage::fromData(data.toByteArray());
} else if (mimeType == QLatin1String("application/x-color") && data.userType() == QMetaType::QByteArray) { } else if (mimeType == QLatin1String("application/x-color") && data.metaType().id() == QMetaType::QByteArray) {
QColor c; QColor c;
QByteArray ba = data.toByteArray(); QByteArray ba = data.toByteArray();
if (ba.size() == 8) { if (ba.size() == 8) {
@ -141,7 +141,7 @@ QVariant QInternalMimeData::retrieveData(const QString &mimeType, QVariant::Type
} else { } else {
qWarning("Qt: Invalid color format"); qWarning("Qt: Invalid color format");
} }
} else if (data.userType() != int(type) && data.userType() == QMetaType::QByteArray) { } else if (data.metaType() != type && data.metaType().id() == QMetaType::QByteArray) {
// try to use mime data's internal conversion stuf. // try to use mime data's internal conversion stuf.
QInternalMimeData *that = const_cast<QInternalMimeData *>(this); QInternalMimeData *that = const_cast<QInternalMimeData *>(this);
that->setData(mimeType, data.toByteArray()); that->setData(mimeType, data.toByteArray());

4
src/gui/kernel/qinternalmimedata_p.h
View File

@ -81,11 +81,11 @@ public:
static QByteArray renderDataHelper(const QString &mimeType, const QMimeData *data); static QByteArray renderDataHelper(const QString &mimeType, const QMimeData *data);
protected: protected:
QVariant retrieveData(const QString &mimeType, QVariant::Type type) const override; QVariant retrieveData(const QString &mimeType, QMetaType type) const override;
virtual bool hasFormat_sys(const QString &mimeType) const = 0; virtual bool hasFormat_sys(const QString &mimeType) const = 0;
virtual QStringList formats_sys() const = 0; virtual QStringList formats_sys() const = 0;
virtual QVariant retrieveData_sys(const QString &mimeType, QVariant::Type type) const = 0; virtual QVariant retrieveData_sys(const QString &mimeType, QMetaType type) const = 0;
}; };
QT_END_NAMESPACE QT_END_NAMESPACE

2
src/gui/platform/windows/qwindowsmime_p.h
View File

@ -74,7 +74,7 @@ public:
// for converting to Qt // for converting to Qt
virtual bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const = 0; virtual bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const = 0;
virtual QVariant convertToMime(const QString &mimeType, IDataObject *pDataObj, QVariant::Type preferredType) const = 0; virtual QVariant convertToMime(const QString &mimeType, IDataObject *pDataObj, QMetaType preferredType) const = 0;
virtual QString mimeForFormat(const FORMATETC &formatetc) const = 0; virtual QString mimeForFormat(const FORMATETC &formatetc) const = 0;
}; };

2
src/plugins/platforms/cocoa/qcocoadrag.h
View File

@ -95,7 +95,7 @@ public:
protected: protected:
bool hasFormat_sys(const QString &mimeType) const; bool hasFormat_sys(const QString &mimeType) const;
QStringList formats_sys() const; QStringList formats_sys() const;
QVariant retrieveData_sys(const QString &mimeType, QVariant::Type type) const; QVariant retrieveData_sys(const QString &mimeType, QMetaType type) const;
public: public:
CFStringRef dropPasteboard; CFStringRef dropPasteboard;
}; };

2
src/plugins/platforms/cocoa/qcocoadrag.mm
View File

@ -332,7 +332,7 @@ QStringList QCocoaDropData::formats_sys() const
return formats; return formats;
} }
QVariant QCocoaDropData::retrieveData_sys(const QString &mimeType, QVariant::Type type) const QVariant QCocoaDropData::retrieveData_sys(const QString &mimeType, QMetaType type) const
{ {
QVariant data; QVariant data;
PasteboardRef board; PasteboardRef board;

2
src/plugins/platforms/cocoa/qmacclipboard.h
View File

@ -92,7 +92,7 @@ public:
QStringList formats() const; QStringList formats() const;
bool hasFormat(const QString &format) const; bool hasFormat(const QString &format) const;
QVariant retrieveData(const QString &format, QVariant::Type) const; QVariant retrieveData(const QString &format, QMetaType) const;
void clear(); void clear();
bool sync() const; bool sync() const;

6
src/plugins/platforms/cocoa/qmacclipboard.mm
View File

@ -84,7 +84,7 @@ OSStatus PasteboardGetItemCountSafe(PasteboardRef paste, ItemCount *cnt)
class QMacMimeData : public QMimeData class QMacMimeData : public QMimeData
{ {
public: public:
QVariant variantData(const QString &mime) { return retrieveData(mime, QVariant::Invalid); } QVariant variantData(const QString &mime) { return retrieveData(mime, QMetaType()); }
private: private:
QMacMimeData(); QMacMimeData();
}; };
@ -313,7 +313,7 @@ public:
QMacPasteboardMimeSource(const QMacPasteboard *p) : QMimeData(), paste(p) { } QMacPasteboardMimeSource(const QMacPasteboard *p) : QMimeData(), paste(p) { }
~QMacPasteboardMimeSource() { } ~QMacPasteboardMimeSource() { }
virtual QStringList formats() const { return paste->formats(); } virtual QStringList formats() const { return paste->formats(); }
virtual QVariant retrieveData(const QString &format, QVariant::Type type) const { return paste->retrieveData(format, type); } virtual QVariant retrieveData(const QString &format, QMetaType type) const { return paste->retrieveData(format, type); }
}; };
QMimeData QMimeData
@ -476,7 +476,7 @@ QMacPasteboard::hasFormat(const QString &format) const
} }
QVariant QVariant
QMacPasteboard::retrieveData(const QString &format, QVariant::Type) const QMacPasteboard::retrieveData(const QString &format, QMetaType) const
{ {
if (!paste) if (!paste)
return QVariant(); return QVariant();

4
src/plugins/platforms/ios/qiosclipboard.mm
View File

@ -138,7 +138,7 @@ public:
~QIOSMimeData() { } ~QIOSMimeData() { }
QStringList formats() const override; QStringList formats() const override;
QVariant retrieveData(const QString &mimeType, QVariant::Type type) const override; QVariant retrieveData(const QString &mimeType, QMetaType type) const override;
private: private:
const QClipboard::Mode m_mode; const QClipboard::Mode m_mode;
@ -160,7 +160,7 @@ QStringList QIOSMimeData::formats() const
return foundMimeTypes; return foundMimeTypes;
} }
QVariant QIOSMimeData::retrieveData(const QString &mimeType, QVariant::Type) const QVariant QIOSMimeData::retrieveData(const QString &mimeType, QMetaType) const
{ {
UIPasteboard *pb = [UIPasteboard pasteboardWithQClipboardMode:m_mode]; UIPasteboard *pb = [UIPasteboard pasteboardWithQClipboardMode:m_mode];
NSArray<NSString *> *pasteboardTypes = [pb pasteboardTypes]; NSArray<NSString *> *pasteboardTypes = [pb pasteboardTypes];

4
src/plugins/platforms/qnx/qqnxclipboard.cpp
View File

@ -141,9 +141,9 @@ public:
} }
protected: protected:
QVariant retrieveData(const QString &mimetype, QVariant::Type preferredType) const override QVariant retrieveData(const QString &mimetype, QMetaType preferredType) const override
{ {
qClipboardDebug() << "mimetype=" << mimetype << "preferredType=" << preferredType; qClipboardDebug() << "mimetype=" << mimetype << "preferredType=" << preferredType.name();
if (is_clipboard_format_present(mimetype.toUtf8().constData()) != 0) if (is_clipboard_format_present(mimetype.toUtf8().constData()) != 0)
return QMimeData::retrieveData(mimetype, preferredType); return QMimeData::retrieveData(mimetype, preferredType);

9
src/plugins/platforms/windows/qwindowsinternalmimedata.cpp
View File

@ -90,8 +90,7 @@ QStringList QWindowsInternalMimeData::formats_sys() const
return fmts; return fmts;
} }
QVariant QWindowsInternalMimeData::retrieveData_sys(const QString &mimeType, QVariant QWindowsInternalMimeData::retrieveData_sys(const QString &mimeType, QMetaType type) const
QVariant::Type type) const
{ {
IDataObject *pDataObj = retrieveDataObject(); IDataObject *pDataObj = retrieveDataObject();
if (!pDataObj) if (!pDataObj)
@ -103,9 +102,9 @@ QVariant QWindowsInternalMimeData::retrieveData_sys(const QString &mimeType,
result = converter->convertToMime(mimeType, pDataObj, type); result = converter->convertToMime(mimeType, pDataObj, type);
releaseDataObject(pDataObj); releaseDataObject(pDataObj);
if (QWindowsContext::verbose) { if (QWindowsContext::verbose) {
qCDebug(lcQpaMime) <<__FUNCTION__ << ' ' << mimeType << ' ' << type qCDebug(lcQpaMime) <<__FUNCTION__ << ' ' << mimeType << ' ' << type.name()
<< " returns " << result.type() << " returns " << result.metaType().name()
<< (result.type() != QVariant::ByteArray ? result.toString() : QStringLiteral("<data>")); << (result.userType() != QVariant::ByteArray ? result.toString() : QStringLiteral("<data>"));
} }
return result; return result;
} }

2
src/plugins/platforms/windows/qwindowsinternalmimedata.h
View File

@ -54,7 +54,7 @@ class QWindowsInternalMimeData : public QInternalMimeData {
public: public:
bool hasFormat_sys(const QString &mimetype) const override; bool hasFormat_sys(const QString &mimetype) const override;
QStringList formats_sys() const override; QStringList formats_sys() const override;
QVariant retrieveData_sys(const QString &mimetype, QVariant::Type preferredType) const override; QVariant retrieveData_sys(const QString &mimetype, QMetaType preferredType) const override;
protected: protected:
virtual IDataObject *retrieveDataObject() const = 0; virtual IDataObject *retrieveDataObject() const = 0;

36
src/plugins/platforms/windows/qwindowsmime.cpp
View File

@ -525,7 +525,7 @@ QDebug operator<<(QDebug d, IDataObject *dataObj)
/*! /*!
\fn QVariant QWindowsMime::convertToMime(const QString &mimeType, IDataObject *pDataObj, \fn QVariant QWindowsMime::convertToMime(const QString &mimeType, IDataObject *pDataObj,
QVariant::Type preferredType) const QMetaType preferredType) const
Returns a QVariant containing the converted data for \a mimeType from \a pDataObj. Returns a QVariant containing the converted data for \a mimeType from \a pDataObj.
If possible the QVariant should be of the \a preferredType to avoid needless conversions. If possible the QVariant should be of the \a preferredType to avoid needless conversions.
@ -548,7 +548,7 @@ class QWindowsMimeText : public QPlatformInterface::Private::QWindowsMime
{ {
public: public:
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override; bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QVariant::Type preferredType) const override; QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QMetaType preferredType) const override;
QString mimeForFormat(const FORMATETC &formatetc) const override; QString mimeForFormat(const FORMATETC &formatetc) const override;
bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override; bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override;
bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override; bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override;
@ -664,7 +664,7 @@ QList<FORMATETC> QWindowsMimeText::formatsForMime(const QString &mimeType, const
return formatics; return formatics;
} }
QVariant QWindowsMimeText::convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QVariant::Type preferredType) const QVariant QWindowsMimeText::convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QMetaType preferredType) const
{ {
QVariant ret; QVariant ret;
@ -691,7 +691,7 @@ QVariant QWindowsMimeText::convertToMime(const QString &mime, LPDATAOBJECT pData
str = QString::fromLocal8Bit(r); str = QString::fromLocal8Bit(r);
} }
} }
if (preferredType == QVariant::String) if (preferredType.id() == QMetaType::QString)
ret = str; ret = str;
else else
ret = std::move(str).toUtf8(); ret = std::move(str).toUtf8();
@ -705,7 +705,7 @@ class QWindowsMimeURI : public QPlatformInterface::Private::QWindowsMime
public: public:
QWindowsMimeURI(); QWindowsMimeURI();
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override; bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QVariant::Type preferredType) const override; QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QMetaType preferredType) const override;
QString mimeForFormat(const FORMATETC &formatetc) const override; QString mimeForFormat(const FORMATETC &formatetc) const override;
bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override; bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override;
bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override; bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override;
@ -819,7 +819,7 @@ QList<FORMATETC> QWindowsMimeURI::formatsForMime(const QString &mimeType, const
return formatics; return formatics;
} }
QVariant QWindowsMimeURI::convertToMime(const QString &mimeType, LPDATAOBJECT pDataObj, QVariant::Type preferredType) const QVariant QWindowsMimeURI::convertToMime(const QString &mimeType, LPDATAOBJECT pDataObj, QMetaType preferredType) const
{ {
if (mimeType == u"text/uri-list") { if (mimeType == u"text/uri-list") {
if (canGetData(CF_HDROP, pDataObj)) { if (canGetData(CF_HDROP, pDataObj)) {
@ -847,7 +847,7 @@ QVariant QWindowsMimeURI::convertToMime(const QString &mimeType, LPDATAOBJECT pD
} }
} }
if (preferredType == QVariant::Url && urls.size() == 1) if (preferredType.id() == QMetaType::QUrl && urls.size() == 1)
return urls.at(0); return urls.at(0);
if (!urls.isEmpty()) if (!urls.isEmpty())
return urls; return urls;
@ -878,7 +878,7 @@ public:
// for converting to Qt // for converting to Qt
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override; bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QVariant::Type preferredType) const override; QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override;
QString mimeForFormat(const FORMATETC &formatetc) const override; QString mimeForFormat(const FORMATETC &formatetc) const override;
private: private:
@ -928,7 +928,7 @@ in bytes). Charset used is mostly utf8, but can be different, ie. we have to loo
...html... ...html...
*/ */
QVariant QWindowsMimeHtml::convertToMime(const QString &mime, IDataObject *pDataObj, QVariant::Type preferredType) const QVariant QWindowsMimeHtml::convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const
{ {
Q_UNUSED(preferredType); Q_UNUSED(preferredType);
QVariant result; QVariant result;
@ -1015,7 +1015,7 @@ public:
// for converting to Qt // for converting to Qt
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override; bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QVariant::Type preferredType) const override; QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override;
QString mimeForFormat(const FORMATETC &formatetc) const override; QString mimeForFormat(const FORMATETC &formatetc) const override;
private: private:
bool hasOriginalDIBV5(IDataObject *pDataObj) const; bool hasOriginalDIBV5(IDataObject *pDataObj) const;
@ -1122,7 +1122,7 @@ bool QWindowsMimeImage::hasOriginalDIBV5(IDataObject *pDataObj) const
return !isSynthesized; return !isSynthesized;
} }
QVariant QWindowsMimeImage::convertToMime(const QString &mimeType, IDataObject *pDataObj, QVariant::Type preferredType) const QVariant QWindowsMimeImage::convertToMime(const QString &mimeType, IDataObject *pDataObj, QMetaType preferredType) const
{ {
Q_UNUSED(preferredType); Q_UNUSED(preferredType);
QVariant result; QVariant result;
@ -1170,7 +1170,7 @@ public:
// for converting to Qt // for converting to Qt
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override; bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QVariant::Type preferredType) const override; QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override;
QString mimeForFormat(const FORMATETC &formatetc) const override; QString mimeForFormat(const FORMATETC &formatetc) const override;
private: private:
@ -1255,14 +1255,14 @@ bool QBuiltInMimes::canConvertToMime(const QString &mimeType, IDataObject *pData
return mit != inFormats.cend() && canGetData(mit.key(), pDataObj); return mit != inFormats.cend() && canGetData(mit.key(), pDataObj);
} }
QVariant QBuiltInMimes::convertToMime(const QString &mimeType, IDataObject *pDataObj, QVariant::Type preferredType) const QVariant QBuiltInMimes::convertToMime(const QString &mimeType, IDataObject *pDataObj, QMetaType preferredType) const
{ {
QVariant val; QVariant val;
if (canConvertToMime(mimeType, pDataObj)) { if (canConvertToMime(mimeType, pDataObj)) {
QByteArray data = getData(inFormats.key(mimeType), pDataObj); QByteArray data = getData(inFormats.key(mimeType), pDataObj);
if (!data.isEmpty()) { if (!data.isEmpty()) {
qCDebug(lcQpaMime) << __FUNCTION__; qCDebug(lcQpaMime) << __FUNCTION__;
if (mimeType == u"text/html" && preferredType == QVariant::String) { if (mimeType == u"text/html" && preferredType == QMetaType(QMetaType::QString)) {
// text/html is in wide chars on windows (compatible with Mozilla) // text/html is in wide chars on windows (compatible with Mozilla)
val = QString::fromWCharArray(reinterpret_cast<const wchar_t *>(data.constData())); val = QString::fromWCharArray(reinterpret_cast<const wchar_t *>(data.constData()));
} else { } else {
@ -1291,7 +1291,7 @@ public:
// for converting to Qt // for converting to Qt
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override; bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QVariant::Type preferredType) const override; QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override;
QString mimeForFormat(const FORMATETC &formatetc) const override; QString mimeForFormat(const FORMATETC &formatetc) const override;
private: private:
@ -1411,7 +1411,7 @@ bool QLastResortMimes::canConvertToMime(const QString &mimeType, IDataObject *pD
return canGetData(cf, pDataObj); return canGetData(cf, pDataObj);
} }
QVariant QLastResortMimes::convertToMime(const QString &mimeType, IDataObject *pDataObj, QVariant::Type preferredType) const QVariant QLastResortMimes::convertToMime(const QString &mimeType, IDataObject *pDataObj, QMetaType preferredType) const
{ {
Q_UNUSED(preferredType); Q_UNUSED(preferredType);
QVariant val; QVariant val;
@ -1572,7 +1572,7 @@ QString QWindowsMimeConverter::clipboardFormatName(int cf)
QVariant QWindowsMimeConverter::convertToMime(const QStringList &mimeTypes, QVariant QWindowsMimeConverter::convertToMime(const QStringList &mimeTypes,
IDataObject *pDataObj, IDataObject *pDataObj,
QVariant::Type preferredType, QMetaType preferredType,
QString *formatIn /* = 0 */) const QString *formatIn /* = 0 */) const
{ {
for (const QString &format : mimeTypes) { for (const QString &format : mimeTypes) {
@ -1589,7 +1589,7 @@ QVariant QWindowsMimeConverter::convertToMime(const QStringList &mimeTypes,
} }
} }
} }
qCDebug(lcQpaMime) << __FUNCTION__ << "fails" << mimeTypes << pDataObj << preferredType; qCDebug(lcQpaMime) << __FUNCTION__ << "fails" << mimeTypes << pDataObj << preferredType.id();
return QVariant(); return QVariant();
} }

2
src/plugins/platforms/windows/qwindowsmime.h
View File

@ -67,7 +67,7 @@ public:
QList<FORMATETC> allFormatsForMime(const QMimeData *mimeData) const; QList<FORMATETC> allFormatsForMime(const QMimeData *mimeData) const;
// Convenience. // Convenience.
QVariant convertToMime(const QStringList &mimeTypes, IDataObject *pDataObj, QVariant::Type preferredType, QVariant convertToMime(const QStringList &mimeTypes, IDataObject *pDataObj, QMetaType preferredType,
QString *format = nullptr) const; QString *format = nullptr) const;
void registerMime(QWindowsMime *mime); void registerMime(QWindowsMime *mime);

4
src/plugins/platforms/xcb/qxcbclipboard.cpp
View File

@ -123,9 +123,9 @@ protected:
return list.contains(format); return list.contains(format);
} }
QVariant retrieveData_sys(const QString &fmt, QVariant::Type type) const override QVariant retrieveData_sys(const QString &fmt, QMetaType type) const override
{ {
auto requestedType = QMetaType::Type(type); auto requestedType = type;
if (fmt.isEmpty() || isEmpty()) if (fmt.isEmpty() || isEmpty())
return QByteArray(); return QByteArray();

10
src/plugins/platforms/xcb/qxcbdrag.cpp
View File

@ -112,9 +112,9 @@ public:
protected: protected:
bool hasFormat_sys(const QString &mimeType) const override; bool hasFormat_sys(const QString &mimeType) const override;
QStringList formats_sys() const override; QStringList formats_sys() const override;
QVariant retrieveData_sys(const QString &mimeType, QVariant::Type type) const override; QVariant retrieveData_sys(const QString &mimeType, QMetaType type) const override;
QVariant xdndObtainData(const QByteArray &format, QMetaType::Type requestedType) const; QVariant xdndObtainData(const QByteArray &format, QMetaType requestedType) const;
QXcbDrag *drag; QXcbDrag *drag;
}; };
@ -1342,14 +1342,14 @@ QXcbDropData::~QXcbDropData()
{ {
} }
QVariant QXcbDropData::retrieveData_sys(const QString &mimetype, QVariant::Type requestedType) const QVariant QXcbDropData::retrieveData_sys(const QString &mimetype, QMetaType requestedType) const
{ {
QByteArray mime = mimetype.toLatin1(); QByteArray mime = mimetype.toLatin1();
QVariant data = xdndObtainData(mime, QMetaType::Type(requestedType)); QVariant data = xdndObtainData(mime, requestedType);
return data; return data;
} }
QVariant QXcbDropData::xdndObtainData(const QByteArray &format, QMetaType::Type requestedType) const QVariant QXcbDropData::xdndObtainData(const QByteArray &format, QMetaType requestedType) const
{ {
QByteArray result; QByteArray result;

8
src/plugins/platforms/xcb/qxcbmime.cpp
View File

@ -158,14 +158,14 @@ QList<xcb_atom_t> QXcbMime::mimeAtomsForFormat(QXcbConnection *connection, const
} }
QVariant QXcbMime::mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a, const QByteArray &d, const QString &format, QVariant QXcbMime::mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a, const QByteArray &d, const QString &format,
QMetaType::Type requestedType, bool hasUtf8) QMetaType requestedType, bool hasUtf8)
{ {
QByteArray data = d; QByteArray data = d;
QString atomName = mimeAtomToString(connection, a); QString atomName = mimeAtomToString(connection, a);
// qDebug() << "mimeConvertDataToFormat" << format << atomName << data; // qDebug() << "mimeConvertDataToFormat" << format << atomName << data;
if (hasUtf8 && atomName == format + QLatin1String(";charset=utf-8")) { if (hasUtf8 && atomName == format + QLatin1String(";charset=utf-8")) {
if (requestedType == QMetaType::QString) if (requestedType.id() == QMetaType::QString)
return QString::fromUtf8(data); return QString::fromUtf8(data);
return data; return data;
} }
@ -255,7 +255,7 @@ QVariant QXcbMime::mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a,
return QVariant(); return QVariant();
} }
xcb_atom_t QXcbMime::mimeAtomForFormat(QXcbConnection *connection, const QString &format, QMetaType::Type requestedType, xcb_atom_t QXcbMime::mimeAtomForFormat(QXcbConnection *connection, const QString &format, QMetaType requestedType,
const QList<xcb_atom_t> &atoms, bool *hasUtf8) const QList<xcb_atom_t> &atoms, bool *hasUtf8)
{ {
*hasUtf8 = false; *hasUtf8 = false;
@ -288,7 +288,7 @@ xcb_atom_t QXcbMime::mimeAtomForFormat(QXcbConnection *connection, const QString
// for string/text requests try to use a format with a well-defined charset // for string/text requests try to use a format with a well-defined charset
// first to avoid encoding problems // first to avoid encoding problems
if (requestedType == QMetaType::QString if (requestedType.id() == QMetaType::QString
&& format.startsWith(QLatin1String("text/")) && format.startsWith(QLatin1String("text/"))
&& !format.contains(QLatin1String("charset="))) { && !format.contains(QLatin1String("charset="))) {

4
src/plugins/platforms/xcb/qxcbmime.h
View File

@ -60,8 +60,8 @@ public:
static bool mimeDataForAtom(QXcbConnection *connection, xcb_atom_t a, QMimeData *mimeData, QByteArray *data, static bool mimeDataForAtom(QXcbConnection *connection, xcb_atom_t a, QMimeData *mimeData, QByteArray *data,
xcb_atom_t *atomFormat, int *dataFormat); xcb_atom_t *atomFormat, int *dataFormat);
static QVariant mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a, const QByteArray &data, const QString &format, static QVariant mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a, const QByteArray &data, const QString &format,
QMetaType::Type requestedType, bool hasUtf8); QMetaType requestedType, bool hasUtf8);
static xcb_atom_t mimeAtomForFormat(QXcbConnection *connection, const QString &format, QMetaType::Type requestedType, static xcb_atom_t mimeAtomForFormat(QXcbConnection *connection, const QString &format, QMetaType requestedType,
const QList<xcb_atom_t> &atoms, bool *hasUtf8); const QList<xcb_atom_t> &atoms, bool *hasUtf8);
}; };

2
src/widgets/widgets/qwidgettextcontrol.cpp
View File

@ -3417,7 +3417,7 @@ QStringList QTextEditMimeData::formats() const
return QMimeData::formats(); return QMimeData::formats();
} }
QVariant QTextEditMimeData::retrieveData(const QString &mimeType, QVariant::Type type) const QVariant QTextEditMimeData::retrieveData(const QString &mimeType, QMetaType type) const
{ {
if (!fragment.isEmpty()) if (!fragment.isEmpty())
setup(); setup();

2
src/widgets/widgets/qwidgettextcontrol_p.h
View File

@ -308,7 +308,7 @@ public:
virtual QStringList formats() const override; virtual QStringList formats() const override;
protected: protected:
virtual QVariant retrieveData(const QString &mimeType, QVariant::Type type) const override; virtual QVariant retrieveData(const QString &mimeType, QMetaType type) const override;
private: private:
void setup() const; void setup() const;

4
tests/auto/corelib/kernel/qmimedata/tst_qmimedata.cpp
View File

@ -325,9 +325,9 @@ void tst_QMimeData::setUrls() const
// test and verify that setData doesn't corrupt url content // test and verify that setData doesn't corrupt url content
foreach (const QString &format, mimeData.formats()) { foreach (const QString &format, mimeData.formats()) {
QVariant before = mimeData.retrieveData(format, QVariant::ByteArray); QVariant before = mimeData.retrieveData(format, QMetaType(QMetaType::QByteArray));
mimeData.setData(format, mimeData.data(format)); mimeData.setData(format, mimeData.data(format));
QVariant after = mimeData.retrieveData(format, QVariant::ByteArray); QVariant after = mimeData.retrieveData(format, QMetaType(QMetaType::QByteArray));
QCOMPARE(after, before); QCOMPARE(after, before);
} }

5
tests/auto/corelib/kernel/qvariant/CMakeLists.txt
View File

@ -33,6 +33,11 @@ qt_add_resource(tst_qvariant "qvariant"
## Scopes: ## Scopes:
##################################################################### #####################################################################
qt_extend_target(tst_qmetatype CONDITION MSVC
COMPILE_OPTIONS
/bigobj
)
qt_extend_target(tst_qvariant CONDITION NOT QT_FEATURE_doubleconversion AND NOT QT_FEATURE_system_doubleconversion qt_extend_target(tst_qvariant CONDITION NOT QT_FEATURE_doubleconversion AND NOT QT_FEATURE_system_doubleconversion
DEFINES DEFINES
QT_NO_DOUBLECONVERSION QT_NO_DOUBLECONVERSION

6
tests/auto/corelib/kernel/qvariant/qvariant.pro
View File

@ -7,6 +7,12 @@ RESOURCES += qvariant.qrc
DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0
qtConfig(c++14): CONFIG += c++14 qtConfig(c++14): CONFIG += c++14
qtConfig(c++1z): CONFIG += c++1z qtConfig(c++1z): CONFIG += c++1z
msvc {
# Prevents "fatal error C1128: number of sections exceeded object file format limit".
QMAKE_CXXFLAGS += /bigobj
}
!qtConfig(doubleconversion):!qtConfig(system-doubleconversion) { !qtConfig(doubleconversion):!qtConfig(system-doubleconversion) {
DEFINES += QT_NO_DOUBLECONVERSION DEFINES += QT_NO_DOUBLECONVERSION
} }

2
tests/auto/gui/kernel/qclipboard/tst_qclipboard.cpp
View File

@ -473,7 +473,7 @@ public:
return false; return false;
} }
QVariant convertToMime(const QString &, IDataObject *, QVariant::Type) const override QVariant convertToMime(const QString &, IDataObject *, QMetaType) const override
{ {
return QVariant(); return QVariant();
} }