Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
qwindowsmimeregistry.cpp
Go to the documentation of this file.
1// Copyright (C) 2020 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3// Qt-Security score:significant reason:default
4
5#include "qwindowsmimeregistry.h"
6#include "qwindowscontext.h"
7
8#include <QtGui/private/qinternalmimedata_p.h>
9#include <QtCore/qbytearraymatcher.h>
10#include <QtCore/qmap.h>
11#include <QtCore/qurl.h>
12#include <QtCore/qdir.h>
13#include <QtCore/qdebug.h>
14#include <QtCore/qbuffer.h>
15#include <QtGui/qimagereader.h>
16#include <QtGui/qimagewriter.h>
17
18#include <shlobj.h>
19#include <algorithm>
20
21QT_BEGIN_NAMESPACE
22
23using namespace Qt::StringLiterals;
24
25/* The MSVC compilers allows multi-byte characters, that has the behavior of
26 * that each character gets shifted into position. 0x73524742 below is for MSVC
27 * equivalent to doing 'sRGB', but this does of course not work
28 * on conformant C++ compilers. */
29#define BMP_LCS_sRGB 0x73524742
30#define BMP_LCS_GM_IMAGES 0x00000004L
31
32struct _CIEXYZ {
33 long ciexyzX, ciexyzY, ciexyzZ;
34};
35
39
66
67static const char dibFormatC[] = "dib";
68
69static inline QByteArray msgConversionError(const char *func, const char *format)
70{
71 QByteArray msg = func;
72 msg += ": Unable to convert DIB image. The image converter plugin for '";
73 msg += format;
74 msg += "' is not available. Available formats: ";
75 const auto &formats = QImageReader::supportedImageFormats();
76 for (const QByteArray &af : formats) {
77 msg += af;
78 msg += ' ';
79 }
80 return msg;
81}
82
83static inline bool readDib(QBuffer &buffer, QImage &img)
84{
85 QImageReader reader(&buffer, dibFormatC);
86 if (!reader.canRead()) {
87 qWarning("%s", msgConversionError(__FUNCTION__, dibFormatC).constData());
88 return false;
89 }
90 img = reader.read();
91 return true;
92}
93
94#if QT_CONFIG(imageformat_bmp)
95static QByteArray writeDib(const QImage &img)
96{
97 QByteArray ba;
98 QBuffer buffer(&ba);
99 buffer.open(QIODevice::ReadWrite);
100 QImageWriter writer(&buffer, dibFormatC);
101 if (!writer.canWrite()) {
102 qWarning("%s", msgConversionError(__FUNCTION__, dibFormatC).constData());
103 return ba;
104 }
105 if (!writer.write(img))
106 ba.clear();
107 return ba;
108}
109
110static bool qt_write_dibv5(QDataStream &s, QImage image)
111{
112 QIODevice* d = s.device();
113 if (!d->isWritable())
114 return false;
115
116 //depth will be always 32
117 qsizetype bpl_bmp = qsizetype(image.width()) * 4;
118 qsizetype size = bpl_bmp * image.height();
119 if (qsizetype(DWORD(size)) != size)
120 return false;
121
122 BMP_BITMAPV5HEADER bi;
123 ZeroMemory(&bi, sizeof(bi));
124 bi.bV5Size = sizeof(BMP_BITMAPV5HEADER);
125 bi.bV5Width = image.width();
126 bi.bV5Height = image.height();
127 bi.bV5Planes = 1;
128 bi.bV5BitCount = 32;
129 bi.bV5Compression = BI_BITFIELDS;
130 bi.bV5SizeImage = DWORD(bpl_bmp * image.height());
131 bi.bV5XPelsPerMeter = 0;
132 bi.bV5YPelsPerMeter = 0;
133 bi.bV5ClrUsed = 0;
134 bi.bV5ClrImportant = 0;
135 bi.bV5BlueMask = 0x000000ff;
136 bi.bV5GreenMask = 0x0000ff00;
137 bi.bV5RedMask = 0x00ff0000;
138 bi.bV5AlphaMask = 0xff000000;
139 bi.bV5CSType = BMP_LCS_sRGB; //LCS_sRGB
140 bi.bV5Intent = BMP_LCS_GM_IMAGES; //LCS_GM_IMAGES
141
142 d->write(reinterpret_cast<const char*>(&bi), bi.bV5Size);
143 if (s.status() != QDataStream::Ok)
144 return false;
145
146 d->write(reinterpret_cast<const char *>(&bi.bV5RedMask), sizeof(bi.bV5RedMask));
147 if (s.status() != QDataStream::Ok)
148 return false;
149
150 d->write(reinterpret_cast<const char *>(&bi.bV5GreenMask), sizeof(bi.bV5GreenMask));
151 if (s.status() != QDataStream::Ok)
152 return false;
153
154 d->write(reinterpret_cast<const char *>(&bi.bV5BlueMask), sizeof(bi.bV5BlueMask));
155 if (s.status() != QDataStream::Ok)
156 return false;
157
158 if (image.format() != QImage::Format_ARGB32)
159 image = std::move(image).convertToFormat(QImage::Format_ARGB32);
160
161 auto *buf = new uchar[bpl_bmp];
162
163 memset(buf, 0, size_t(bpl_bmp));
164 for (int y=image.height()-1; y>=0; y--) {
165 // write the image bits
166 const QRgb *p = reinterpret_cast<const QRgb *>(image.constScanLine(y));
167 const QRgb *end = p + image.width();
168 uchar *b = buf;
169 while (p < end) {
170 int alpha = qAlpha(*p);
171 if (alpha) {
172 *b++ = uchar(qBlue(*p));
173 *b++ = uchar(qGreen(*p));
174 *b++ = uchar(qRed(*p));
175 } else {
176 //white for fully transparent pixels.
177 *b++ = 0xff;
178 *b++ = 0xff;
179 *b++ = 0xff;
180 }
181 *b++ = uchar(alpha);
182 p++;
183 }
184 d->write(reinterpret_cast<const char *>(buf), bpl_bmp);
185 if (s.status() != QDataStream::Ok) {
186 delete[] buf;
187 return false;
188 }
189 }
190 delete[] buf;
191 return true;
192}
193#endif //QT_CONFIG(imageformat_bmp)
194
195// helpers for using global memory
196
197static int getCf(const FORMATETC &formatetc)
198{
199 return formatetc.cfFormat;
200}
201
202static FORMATETC setCf(int cf)
203{
204 FORMATETC formatetc;
205 formatetc.cfFormat = CLIPFORMAT(cf);
206 formatetc.dwAspect = DVASPECT_CONTENT;
207 formatetc.lindex = -1;
208 formatetc.ptd = nullptr;
209 formatetc.tymed = TYMED_HGLOBAL;
210 return formatetc;
211}
212
213static bool setData(const QByteArray &data, STGMEDIUM *pmedium, DWORD tymed = TYMED_HGLOBAL)
214{
215 HGLOBAL hData = GlobalAlloc(0, SIZE_T(data.size()));
216 if (!hData)
217 return false;
218
219 void *out = GlobalLock(hData);
220 memcpy(out, data.data(), size_t(data.size()));
221 GlobalUnlock(hData);
222
223 // MS Office (and other consumers that prefer streamed delivery for image
224 // payloads) request CF_PNG via TYMED_ISTREAM rather than TYMED_HGLOBAL,
225 // and reject the result if the returned tymed doesn't match. Wrap the
226 // buffer in an IStream only when TYMED_HGLOBAL was not requested, so that
227 // legacy consumers asking for HGLOBAL (or HGLOBAL|ISTREAM) keep getting
228 // it. (QTBUG-126191)
229 if (!(tymed & TYMED_HGLOBAL) && (tymed & TYMED_ISTREAM)) {
230 IStream *stream = nullptr;
231 if (FAILED(::CreateStreamOnHGlobal(hData, /*fDeleteOnRelease*/ TRUE, &stream))) {
232 GlobalFree(hData);
233 return false;
234 }
235 pmedium->tymed = TYMED_ISTREAM;
236 pmedium->pstm = stream;
237 pmedium->pUnkForRelease = nullptr;
238 return true;
239 }
240
241 pmedium->tymed = TYMED_HGLOBAL;
242 pmedium->hGlobal = hData;
243 pmedium->pUnkForRelease = nullptr;
244 return true;
245}
246
247static QByteArray getData(int cf, IDataObject *pDataObj, int lindex = -1)
248{
249 QByteArray data;
250 FORMATETC formatetc = setCf(cf);
251 formatetc.lindex = lindex;
252 STGMEDIUM s;
253 if (pDataObj->GetData(&formatetc, &s) == S_OK) {
254 // Explorer's zipped-folder shell extension returns S_OK with a null
255 // or zero-sized hGlobal for CFSTR_FILECONTENTS (QTBUG-126980); fall
256 // through to the IStream path in that case.
257 if (s.hGlobal && GlobalSize(s.hGlobal) > 0) {
258 if (const void *val = GlobalLock(s.hGlobal)) {
259 data = QByteArray::fromRawData(reinterpret_cast<const char *>(val),
260 qsizetype(GlobalSize(s.hGlobal)));
261 data.detach();
262 GlobalUnlock(s.hGlobal);
263 }
264 }
265 ReleaseStgMedium(&s);
266 }
267 if (data.isEmpty()) {
268 //Try reading IStream data
269 formatetc.tymed = TYMED_ISTREAM;
270 if (pDataObj->GetData(&formatetc, &s) == S_OK) {
271 char szBuffer[4096];
272 ULONG actualRead = 0;
273 LARGE_INTEGER pos = {{0, 0}};
274 //Move to front (can fail depending on the data model implemented)
275 HRESULT hr = s.pstm->Seek(pos, STREAM_SEEK_SET, nullptr);
276 while(SUCCEEDED(hr)){
277 hr = s.pstm->Read(szBuffer, sizeof(szBuffer), &actualRead);
278 if (SUCCEEDED(hr) && actualRead > 0) {
279 data += QByteArray::fromRawData(szBuffer, int(actualRead));
280 }
281 if (actualRead != sizeof(szBuffer))
282 break;
283 }
284 data.detach();
285 ReleaseStgMedium(&s);
286 }
287 }
288 return data;
289}
290
291static bool canGetData(int cf, IDataObject * pDataObj)
292{
293 FORMATETC formatetc = setCf(cf);
294 if (pDataObj->QueryGetData(&formatetc) != S_OK){
295 formatetc.tymed = TYMED_ISTREAM;
296 return pDataObj->QueryGetData(&formatetc) == S_OK;
297 }
298 return true;
299}
300
301#ifndef QT_NO_DEBUG_STREAM
302QDebug operator<<(QDebug d, const FORMATETC &tc)
303{
304 QDebugStateSaver saver(d);
305 d.nospace();
306 d << "FORMATETC(cfFormat=" << tc.cfFormat << ' ';
307 switch (tc.cfFormat) {
308 case CF_TEXT:
309 d << "CF_TEXT";
310 break;
311 case CF_BITMAP:
312 d << "CF_BITMAP";
313 break;
314 case CF_TIFF:
315 d << "CF_TIFF";
316 break;
317 case CF_OEMTEXT:
318 d << "CF_OEMTEXT";
319 break;
320 case CF_DIB:
321 d << "CF_DIB";
322 break;
323 case CF_DIBV5:
324 d << "CF_DIBV5";
325 break;
326 case CF_UNICODETEXT:
327 d << "CF_UNICODETEXT";
328 break;
329 case CF_ENHMETAFILE:
330 d << "CF_ENHMETAFILE";
331 break;
332 default:
333 d << QWindowsMimeRegistry::clipboardFormatName(tc.cfFormat);
334 break;
335 }
336 d << ", dwAspect=" << tc.dwAspect << ", lindex=" << tc.lindex
337 << ", tymed=" << tc.tymed << ", ptd=" << tc.ptd << ')';
338 return d;
339}
340
341QDebug operator<<(QDebug d, IDataObject *dataObj)
342{
343 QDebugStateSaver saver(d);
344 d.nospace();
345 d.noquote();
346 d << "IDataObject(";
347 if (dataObj) { // Output formats contained in IDataObject.
348 IEnumFORMATETC *enumFormatEtc;
349 if (SUCCEEDED(dataObj->EnumFormatEtc(DATADIR_GET, &enumFormatEtc)) && enumFormatEtc) {
350 FORMATETC formatEtc[1];
351 ULONG fetched;
352 if (SUCCEEDED(enumFormatEtc->Reset())) {
353 while (SUCCEEDED(enumFormatEtc->Next(1, formatEtc, &fetched)) && fetched)
354 d << formatEtc[0] << ',';
355 enumFormatEtc->Release();
356 }
357 }
358 } else {
359 d << "0x0";
360 }
361 d << ')';
362 return d;
363}
364#endif // !QT_NO_DEBUG_STREAM
365
366class QWindowsMimeText : public QWindowsMimeConverter
367{
368public:
369 bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
370 QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QMetaType preferredType) const override;
371 QString mimeForFormat(const FORMATETC &formatetc) const override;
372 bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override;
373 bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override;
374 QList<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override;
375};
376
377bool QWindowsMimeText::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const
378{
379 int cf = getCf(formatetc);
380 return (cf == CF_UNICODETEXT || (cf == CF_TEXT && GetACP() != CP_UTF8)) && mimeData->hasText();
381}
382
383/*
384text/plain is defined as using CRLF, but so many programs don't,
385and programmers just look for '\n' in strings.
386Windows really needs CRLF, so we ensure it here.
387*/
388bool QWindowsMimeText::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const
389{
390 if (canConvertFromMime(formatetc, mimeData)) {
391 QByteArray data;
392 int cf = getCf(formatetc);
393 if (cf == CF_TEXT) {
394 data = mimeData->text().toLocal8Bit();
395 // Anticipate required space for CRLFs at 1/40
396 int maxsize=data.size()+data.size()/40+3;
397 QByteArray r(maxsize, '\0');
398 char* o = r.data();
399 const char* d = data.data();
400 const int s = data.size();
401 bool cr=false;
402 int j=0;
403 for (int i=0; i<s; i++) {
404 char c = d[i];
405 if (c=='\r')
406 cr=true;
407 else {
408 if (c=='\n') {
409 if (!cr)
410 o[j++]='\r';
411 }
412 cr=false;
413 }
414 o[j++]=c;
415 if (j+3 >= maxsize) {
416 maxsize += maxsize/4;
417 r.resize(maxsize);
418 o = r.data();
419 }
420 }
421 o[j]=0;
422 return setData(r, pmedium);
423 }
424 if (cf == CF_UNICODETEXT) {
425 QString str = mimeData->text();
426 const QChar *u = str.unicode();
427 QString res;
428 const int s = str.length();
429 int maxsize = s + s/40 + 3;
430 res.resize(maxsize);
431 int ri = 0;
432 bool cr = false;
433 for (int i=0; i < s; ++i) {
434 if (*u == u'\r')
435 cr = true;
436 else {
437 if (*u == u'\n' && !cr)
438 res[ri++] = u'\r';
439 cr = false;
440 }
441 res[ri++] = *u;
442 if (ri+3 >= maxsize) {
443 maxsize += maxsize/4;
444 res.resize(maxsize);
445 }
446 ++u;
447 }
448 res.truncate(ri);
449 const int byteLength = res.length() * int(sizeof(ushort));
450 QByteArray r(byteLength + 2, '\0');
451 memcpy(r.data(), res.unicode(), size_t(byteLength));
452 r[byteLength] = 0;
453 r[byteLength+1] = 0;
454 return setData(r, pmedium);
455 }
456 }
457 return false;
458}
459
460bool QWindowsMimeText::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const
461{
462 return mimeType.startsWith(u"text/plain")
463 && (canGetData(CF_UNICODETEXT, pDataObj)
464 || canGetData(CF_TEXT, pDataObj));
465}
466
467QString QWindowsMimeText::mimeForFormat(const FORMATETC &formatetc) const
468{
469 int cf = getCf(formatetc);
470 if (cf == CF_UNICODETEXT || cf == CF_TEXT)
471 return u"text/plain"_s;
472 return QString();
473}
474
475
476QList<FORMATETC> QWindowsMimeText::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const
477{
478 QList<FORMATETC> formatics;
479 if (mimeType.startsWith(u"text/plain") && mimeData->hasText()) {
480 formatics += setCf(CF_UNICODETEXT);
481 if (GetACP() != CP_UTF8)
482 formatics += setCf(CF_TEXT);
483 }
484 return formatics;
485}
486
487QVariant QWindowsMimeText::convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QMetaType preferredType) const
488{
489 QVariant ret;
490
491 if (canConvertToMime(mime, pDataObj)) {
492 QString str;
493 QByteArray data = getData(CF_UNICODETEXT, pDataObj);
494 if (!data.isEmpty()) {
495 str = QString::fromWCharArray(reinterpret_cast<const wchar_t *>(data.constData()));
496 str.replace("\r\n"_L1, "\n"_L1);
497 } else {
498 data = getData(CF_TEXT, pDataObj);
499 if (!data.isEmpty()) {
500 const char* d = data.data();
501 const unsigned s = unsigned(qstrlen(d));
502 QByteArray r(data.size()+1, '\0');
503 char* o = r.data();
504 int j=0;
505 for (unsigned i = 0; i < s; ++i) {
506 char c = d[i];
507 if (c!='\r')
508 o[j++]=c;
509 }
510 o[j]=0;
511 str = QString::fromLocal8Bit(r);
512 }
513 }
514 if (preferredType.id() == QMetaType::QString)
515 ret = str;
516 else
517 ret = std::move(str).toUtf8();
518 }
519 qCDebug(lcQpaMime) << __FUNCTION__ << ret;
520 return ret;
521}
522
523class QWindowsMimeURI : public QWindowsMimeConverter
524{
525public:
526 QWindowsMimeURI();
527 bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
528 QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QMetaType preferredType) const override;
529 QString mimeForFormat(const FORMATETC &formatetc) const override;
530 bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override;
531 bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override;
532 QList<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override;
533private:
534 int CF_INETURL_W; // wide char version
535 int CF_INETURL;
536};
537
538QWindowsMimeURI::QWindowsMimeURI()
539{
540 CF_INETURL_W = registerMimeType(u"UniformResourceLocatorW"_s);
541 CF_INETURL = registerMimeType(u"UniformResourceLocator"_s);
542}
543
544bool QWindowsMimeURI::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const
545{
546 if (mimeData->hasUrls() && getCf(formatetc) == CF_HDROP) {
547 const auto urls = mimeData->urls();
548 for (const QUrl &url : urls) {
549 if (url.isLocalFile())
550 return true;
551 }
552 }
553 return (getCf(formatetc) == CF_INETURL_W || getCf(formatetc) == CF_INETURL) && mimeData->hasUrls();
554}
555
556bool QWindowsMimeURI::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const
557{
558 if (canConvertFromMime(formatetc, mimeData)) {
559 if (getCf(formatetc) == CF_HDROP) {
560 const auto &urls = mimeData->urls();
561 QStringList fileNames;
562 size_t size = sizeof(DROPFILES) + 2;
563 for (const QUrl &url : urls) {
564 const QString fn = QDir::toNativeSeparators(url.toLocalFile());
565 if (!fn.isEmpty()) {
566 size += sizeof(ushort) * size_t(fn.length() + 1);
567 fileNames.append(fn);
568 }
569 }
570
571 QByteArray result(int(size), '\0');
572 auto* d = reinterpret_cast<DROPFILES *>(result.data());
573 d->pFiles = sizeof(DROPFILES);
574 GetCursorPos(&d->pt); // try
575 d->fNC = true;
576 char *files = (reinterpret_cast<char*>(d)) + d->pFiles;
577
578 d->fWide = true;
579 auto *f = reinterpret_cast<wchar_t *>(files);
580 for (int i=0; i<fileNames.size(); i++) {
581 const auto l = size_t(fileNames.at(i).length());
582 memcpy(f, fileNames.at(i).data(), l * sizeof(ushort));
583 f += l;
584 *f++ = 0;
585 }
586 *f = 0;
587
588 return setData(result, pmedium);
589 }
590 if (getCf(formatetc) == CF_INETURL_W) {
591 const auto urls = mimeData->urls();
592 QByteArray result;
593 if (!urls.isEmpty()) {
594 const QString url = urls.at(0).toString();
595 result = QByteArray(reinterpret_cast<const char *>(url.data()),
596 url.length() * int(sizeof(ushort)));
597 }
598 result.append('\0');
599 result.append('\0');
600 return setData(result, pmedium);
601 }
602 if (getCf(formatetc) == CF_INETURL) {
603 const auto urls = mimeData->urls();
604 QByteArray result;
605 if (!urls.isEmpty())
606 result = urls.at(0).toString().toLocal8Bit();
607 return setData(result, pmedium);
608 }
609 }
610
611 return false;
612}
613
614bool QWindowsMimeURI::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const
615{
616 return mimeType == u"text/uri-list"
617 && (canGetData(CF_HDROP, pDataObj) || canGetData(CF_INETURL_W, pDataObj) || canGetData(CF_INETURL, pDataObj));
618}
619
620QString QWindowsMimeURI::mimeForFormat(const FORMATETC &formatetc) const
621{
622 QString format;
623 if (getCf(formatetc) == CF_HDROP || getCf(formatetc) == CF_INETURL_W || getCf(formatetc) == CF_INETURL)
624 format = u"text/uri-list"_s;
625 return format;
626}
627
628QList<FORMATETC> QWindowsMimeURI::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const
629{
630 QList<FORMATETC> formatics;
631 if (mimeType == u"text/uri-list") {
632 if (canConvertFromMime(setCf(CF_HDROP), mimeData))
633 formatics += setCf(CF_HDROP);
634 if (canConvertFromMime(setCf(CF_INETURL_W), mimeData))
635 formatics += setCf(CF_INETURL_W);
636 if (canConvertFromMime(setCf(CF_INETURL), mimeData))
637 formatics += setCf(CF_INETURL);
638 }
639 return formatics;
640}
641
642QVariant QWindowsMimeURI::convertToMime(const QString &mimeType, LPDATAOBJECT pDataObj, QMetaType preferredType) const
643{
644 if (mimeType == u"text/uri-list") {
645 if (canGetData(CF_HDROP, pDataObj)) {
646 QList<QVariant> urls;
647
648 QByteArray data = getData(CF_HDROP, pDataObj);
649 if (data.isEmpty())
650 return QVariant();
651
652 const auto *hdrop = reinterpret_cast<const DROPFILES *>(data.constData());
653 if (hdrop->fWide) {
654 const auto *filesw = reinterpret_cast<const wchar_t *>(data.constData() + hdrop->pFiles);
655 int i = 0;
656 while (filesw[i]) {
657 QString fileurl = QString::fromWCharArray(filesw + i);
658 urls += QUrl::fromLocalFile(fileurl);
659 i += fileurl.length()+1;
660 }
661 } else {
662 const char* files = reinterpret_cast<const char *>(data.constData() + hdrop->pFiles);
663 int i=0;
664 while (files[i]) {
665 urls += QUrl::fromLocalFile(QString::fromLocal8Bit(files+i));
666 i += int(strlen(files+i))+1;
667 }
668 }
669
670 if (preferredType.id() == QMetaType::QUrl && urls.size() == 1)
671 return urls.at(0);
672 if (!urls.isEmpty())
673 return urls;
674 } else if (canGetData(CF_INETURL_W, pDataObj)) {
675 QByteArray data = getData(CF_INETURL_W, pDataObj);
676 if (data.isEmpty())
677 return QVariant();
678 return QUrl(QString::fromWCharArray(reinterpret_cast<const wchar_t *>(data.constData())));
679 } else if (canGetData(CF_INETURL, pDataObj)) {
680 QByteArray data = getData(CF_INETURL, pDataObj);
681 if (data.isEmpty())
682 return QVariant();
683 return QUrl(QString::fromLocal8Bit(data.constData()));
684 }
685 }
686 return QVariant();
687}
688
689class QWindowsMimeHtml : public QWindowsMimeConverter
690{
691public:
692 QWindowsMimeHtml();
693
694 // for converting from Qt
695 bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override;
696 bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const override;
697 QList<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override;
698
699 // for converting to Qt
700 bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
701 QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override;
702 QString mimeForFormat(const FORMATETC &formatetc) const override;
703
704private:
705 int CF_HTML;
706};
707
708QWindowsMimeHtml::QWindowsMimeHtml()
709{
710 CF_HTML = registerMimeType(u"HTML Format"_s);
711}
712
713QList<FORMATETC> QWindowsMimeHtml::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const
714{
715 QList<FORMATETC> formatetcs;
716 if (mimeType == u"text/html" && (!mimeData->html().isEmpty()))
717 formatetcs += setCf(CF_HTML);
718 return formatetcs;
719}
720
721QString QWindowsMimeHtml::mimeForFormat(const FORMATETC &formatetc) const
722{
723 if (getCf(formatetc) == CF_HTML)
724 return u"text/html"_s;
725 return QString();
726}
727
728bool QWindowsMimeHtml::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const
729{
730 return mimeType == u"text/html" && canGetData(CF_HTML, pDataObj);
731}
732
733
734bool QWindowsMimeHtml::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const
735{
736 return getCf(formatetc) == CF_HTML && (!mimeData->html().isEmpty());
737}
738
739/*
740The windows HTML clipboard format is as follows (xxxxxxxxxx is a 10 integer number giving the positions
741in bytes). Charset used is mostly utf8, but can be different, ie. we have to look for the <meta> charset tag
742
743 Version: 1.0
744 StartHTML:xxxxxxxxxx
745 EndHTML:xxxxxxxxxx
746 StartFragment:xxxxxxxxxx
747 EndFragment:xxxxxxxxxx
748 ...html...
749
750*/
751QVariant QWindowsMimeHtml::convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const
752{
753 Q_UNUSED(preferredType);
754 QVariant result;
755 if (canConvertToMime(mime, pDataObj)) {
756 QByteArray html = getData(CF_HTML, pDataObj);
757 static constexpr auto startMatcher = qMakeStaticByteArrayMatcher("StartHTML:");
758 static constexpr auto endMatcher = qMakeStaticByteArrayMatcher("EndHTML:");
759 qCDebug(lcQpaMime) << __FUNCTION__ << "raw:" << html;
760 int start = startMatcher.indexIn(html);
761 int end = endMatcher.indexIn(html);
762
763 if (start != -1) {
764 int startOffset = start + 10;
765 int i = startOffset;
766 while (html.at(i) != '\r' && html.at(i) != '\n')
767 ++i;
768 QByteArray bytecount = html.mid(startOffset, i - startOffset);
769 start = bytecount.toInt();
770 }
771
772 if (end != -1) {
773 int endOffset = end + 8;
774 int i = endOffset ;
775 while (html.at(i) != '\r' && html.at(i) != '\n')
776 ++i;
777 QByteArray bytecount = html.mid(endOffset , i - endOffset);
778 end = bytecount.toInt();
779 }
780
781 if (end > start && start > 0) {
782 html = html.mid(start, end - start);
783 html.replace('\r', "");
784 result = QString::fromUtf8(html);
785 }
786 }
787 return result;
788}
789
790bool QWindowsMimeHtml::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const
791{
792 if (canConvertFromMime(formatetc, mimeData)) {
793 QByteArray data = mimeData->html().toUtf8();
794 QByteArray result =
795 "Version:1.0\r\n" // 0-12
796 "StartHTML:0000000107\r\n" // 13-35
797 "EndHTML:0000000000\r\n" // 36-55
798 "StartFragment:0000000000\r\n" // 56-81
799 "EndFragment:0000000000\r\n\r\n"; // 82-107
800
801 static constexpr auto startFragmentMatcher = qMakeStaticByteArrayMatcher("<!--StartFragment-->");
802 static constexpr auto endFragmentMatcher = qMakeStaticByteArrayMatcher("<!--EndFragment-->");
803
804 if (startFragmentMatcher.indexIn(data) == -1)
805 result += "<!--StartFragment-->";
806 result += data;
807 if (endFragmentMatcher.indexIn(data) == -1)
808 result += "<!--EndFragment-->";
809
810 // set the correct number for EndHTML
811 QByteArray pos = QByteArray::number(result.size());
812 memcpy(reinterpret_cast<char *>(result.data() + 53 - pos.length()), pos.constData(), size_t(pos.length()));
813
814 // set correct numbers for StartFragment and EndFragment
815 pos = QByteArray::number(startFragmentMatcher.indexIn(result) + 20);
816 memcpy(reinterpret_cast<char *>(result.data() + 79 - pos.length()), pos.constData(), size_t(pos.length()));
817 pos = QByteArray::number(endFragmentMatcher.indexIn(result));
818 memcpy(reinterpret_cast<char *>(result.data() + 103 - pos.length()), pos.constData(), size_t(pos.length()));
819
820 return setData(result, pmedium);
821 }
822 return false;
823}
824
825
826#if QT_CONFIG(imageformat_bmp)
827class QWindowsMimeImage : public QWindowsMimeConverter
828{
829public:
830 QWindowsMimeImage();
831 // for converting from Qt
832 bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override;
833 bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const override;
834 QList<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override;
835
836 // for converting to Qt
837 bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
838 QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override;
839 QString mimeForFormat(const FORMATETC &formatetc) const override;
840private:
841 bool hasOriginalDIBV5(IDataObject *pDataObj) const;
842 UINT CF_PNG;
843};
844
845QWindowsMimeImage::QWindowsMimeImage()
846{
847 CF_PNG = RegisterClipboardFormat(L"PNG");
848}
849
850QList<FORMATETC> QWindowsMimeImage::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const
851{
852 QList<FORMATETC> formatetcs;
853 if (mimeData->hasImage() && mimeType == u"application/x-qt-image") {
854 auto image = qvariant_cast<QImage>(mimeData->imageData());
855 if (!image.isNull() && image.hasAlphaChannel()) {
856 // CF_PNG is the only format modern MS Office (and other apps that
857 // deliver image data via TYMED_ISTREAM) reads with alpha
858 // preserved (QTBUG-126191).
859 formatetcs += setCf(CF_PNG);
860 formatetcs += setCf(CF_DIBV5);
861 }
862 formatetcs += setCf(CF_DIB);
863 }
864 if (!formatetcs.isEmpty())
865 qCDebug(lcQpaMime) << __FUNCTION__ << mimeType << formatetcs;
866 return formatetcs;
867}
868
869QString QWindowsMimeImage::mimeForFormat(const FORMATETC &formatetc) const
870{
871 int cf = getCf(formatetc);
872 if (cf == CF_DIB || cf == CF_DIBV5 || cf == int(CF_PNG))
873 return u"application/x-qt-image"_s;
874 return QString();
875}
876
877bool QWindowsMimeImage::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const
878{
879 return mimeType == u"application/x-qt-image"
880 && (canGetData(CF_DIB, pDataObj) || canGetData(CF_PNG, pDataObj));
881}
882
883bool QWindowsMimeImage::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const
884{
885 int cf = getCf(formatetc);
886 if (!mimeData->hasImage())
887 return false;
888 const QImage image = qvariant_cast<QImage>(mimeData->imageData());
889 if (image.isNull())
890 return false;
891 // QTBUG-64322: Use PNG only for transparent images as otherwise MS PowerPoint
892 // cannot handle it.
893 return cf == CF_DIBV5 || cf == CF_DIB
894 || (cf == int(CF_PNG) && image.hasAlphaChannel());
895}
896
897bool QWindowsMimeImage::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const
898{
899 int cf = getCf(formatetc);
900 if ((cf == CF_DIB || cf == CF_DIBV5 || cf == int(CF_PNG)) && mimeData->hasImage()) {
901 auto img = qvariant_cast<QImage>(mimeData->imageData());
902 if (img.isNull())
903 return false;
904 QByteArray ba;
905 if (cf == CF_DIB) {
906 if (img.format() > QImage::Format_ARGB32)
907 img = std::move(img).convertToFormat(QImage::Format_RGB32);
908 const QByteArray ba = writeDib(img);
909 if (!ba.isEmpty())
910 return setData(ba, pmedium);
911 } else if (cf == int(CF_PNG)) {
912 QBuffer buffer(&ba);
913 const bool written = buffer.open(QIODevice::WriteOnly) && img.save(&buffer, "PNG");
914 buffer.close();
915 if (written)
916 return setData(ba, pmedium, formatetc.tymed);
917 } else {
918 QDataStream s(&ba, QIODevice::WriteOnly);
919 s.setByteOrder(QDataStream::LittleEndian);// Intel byte order ####
920 if (qt_write_dibv5(s, std::move(img)))
921 return setData(ba, pmedium);
922 }
923 }
924 return false;
925}
926
927bool QWindowsMimeImage::hasOriginalDIBV5(IDataObject *pDataObj) const
928{
929 bool isSynthesized = true;
930 IEnumFORMATETC *pEnum = nullptr;
931 HRESULT res = pDataObj->EnumFormatEtc(1, &pEnum);
932 if (res == S_OK && pEnum) {
933 FORMATETC fc;
934 while ((res = pEnum->Next(1, &fc, nullptr)) == S_OK) {
935 if (fc.ptd)
936 CoTaskMemFree(fc.ptd);
937 if (fc.cfFormat == CF_DIB)
938 break;
939 if (fc.cfFormat == CF_DIBV5) {
940 isSynthesized = false;
941 break;
942 }
943 }
944 pEnum->Release();
945 }
946 return !isSynthesized;
947}
948
949QVariant QWindowsMimeImage::convertToMime(const QString &mimeType, IDataObject *pDataObj, QMetaType preferredType) const
950{
951 Q_UNUSED(preferredType);
952 QVariant result;
953 if (mimeType != u"application/x-qt-image")
954 return result;
955 // Try to convert from DIBV5 as it is the most widespread format that supports transparency,
956 // but avoid synthesizing it, as that typically loses transparency, e.g. from Office
957 const bool canGetDibV5 = canGetData(CF_DIBV5, pDataObj);
958 const bool hasOrigDibV5 = canGetDibV5 ? hasOriginalDIBV5(pDataObj) : false;
959 qCDebug(lcQpaMime) << "canGetDibV5:" << canGetDibV5 << "hasOrigDibV5:" << hasOrigDibV5;
960 // PNG, MS Office place this (undocumented)
961 if (!hasOrigDibV5 && canGetData(CF_PNG, pDataObj)) {
962 qCDebug(lcQpaMime) << "Decoding PNG";
963 QImage img;
964 QByteArray data = getData(CF_PNG, pDataObj);
965 if (img.loadFromData(data, "PNG")) {
966 return img;
967 }
968 }
969
970 if (canGetDibV5 || canGetData(CF_DIB, pDataObj)) {
971 qCDebug(lcQpaMime) << "Decoding DIB";
972 QImage img;
973 QByteArray data = getData(canGetDibV5 ? CF_DIBV5 : CF_DIB, pDataObj);
974 QBuffer buffer(&data);
975 if (readDib(buffer, img))
976 return img;
977 }
978 // Failed
979 return result;
980}
981#endif //QT_CONFIG(imageformat_bmp)
982
983class QBuiltInMimes : public QWindowsMimeConverter
984{
985public:
986 QBuiltInMimes();
987
988 // for converting from Qt
989 bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override;
990 bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const override;
991 QList<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override;
992
993 // for converting to Qt
994 bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
995 QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override;
996 QString mimeForFormat(const FORMATETC &formatetc) const override;
997
998private:
999 QMap<int, QString> outFormats;
1000 QMap<int, QString> inFormats;
1001};
1002
1003QBuiltInMimes::QBuiltInMimes()
1004: QWindowsMimeConverter()
1005{
1006 outFormats.insert(registerMimeType(u"application/x-color"_s), u"application/x-color"_s);
1007 inFormats.insert(registerMimeType(u"application/x-color"_s), u"application/x-color"_s);
1008}
1009
1010bool QBuiltInMimes::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const
1011{
1012 // really check
1013 return formatetc.tymed & TYMED_HGLOBAL
1014 && outFormats.contains(formatetc.cfFormat)
1015 && mimeData->formats().contains(outFormats.value(formatetc.cfFormat));
1016}
1017
1018bool QBuiltInMimes::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const
1019{
1020 if (canConvertFromMime(formatetc, mimeData)) {
1021 QByteArray data;
1022 if (outFormats.value(getCf(formatetc)) == u"text/html") {
1023 // text/html is in wide chars on windows (compatible with mozillia)
1024 QString html = mimeData->html();
1025 // same code as in the text converter up above
1026 const QChar *u = html.unicode();
1027 QString res;
1028 const int s = html.length();
1029 int maxsize = s + s/40 + 3;
1030 res.resize(maxsize);
1031 int ri = 0;
1032 bool cr = false;
1033 for (int i=0; i < s; ++i) {
1034 if (*u == u'\r')
1035 cr = true;
1036 else {
1037 if (*u == u'\n' && !cr)
1038 res[ri++] = u'\r';
1039 cr = false;
1040 }
1041 res[ri++] = *u;
1042 if (ri+3 >= maxsize) {
1043 maxsize += maxsize/4;
1044 res.resize(maxsize);
1045 }
1046 ++u;
1047 }
1048 res.truncate(ri);
1049 const int byteLength = res.length() * int(sizeof(ushort));
1050 QByteArray r(byteLength + 2, '\0');
1051 memcpy(r.data(), res.unicode(), size_t(byteLength));
1052 r[byteLength] = 0;
1053 r[byteLength+1] = 0;
1054 data = r;
1055 } else {
1056#if QT_CONFIG(draganddrop)
1057 data = QInternalMimeData::renderDataHelper(outFormats.value(getCf(formatetc)), mimeData);
1058#endif // QT_CONFIG(draganddrop)
1059 }
1060 return setData(data, pmedium);
1061 }
1062 return false;
1063}
1064
1065QList<FORMATETC> QBuiltInMimes::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const
1066{
1067 QList<FORMATETC> formatetcs;
1068 const auto mit = std::find(outFormats.cbegin(), outFormats.cend(), mimeType);
1069 if (mit != outFormats.cend() && mimeData->formats().contains(mimeType))
1070 formatetcs += setCf(mit.key());
1071 return formatetcs;
1072}
1073
1074bool QBuiltInMimes::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const
1075{
1076 const auto mit = std::find(inFormats.cbegin(), inFormats.cend(), mimeType);
1077 return mit != inFormats.cend() && canGetData(mit.key(), pDataObj);
1078}
1079
1080QVariant QBuiltInMimes::convertToMime(const QString &mimeType, IDataObject *pDataObj, QMetaType preferredType) const
1081{
1082 QVariant val;
1083 if (canConvertToMime(mimeType, pDataObj)) {
1084 QByteArray data = getData(inFormats.key(mimeType), pDataObj);
1085 if (!data.isEmpty()) {
1086 qCDebug(lcQpaMime) << __FUNCTION__;
1087 if (mimeType == u"text/html" && preferredType == QMetaType(QMetaType::QString)) {
1088 // text/html is in wide chars on windows (compatible with Mozilla)
1089 val = QString::fromWCharArray(reinterpret_cast<const wchar_t *>(data.constData()));
1090 } else {
1091 val = data; // it should be enough to return the data and let QMimeData do the rest.
1092 }
1093 }
1094 }
1095 return val;
1096}
1097
1098QString QBuiltInMimes::mimeForFormat(const FORMATETC &formatetc) const
1099{
1100 return inFormats.value(getCf(formatetc));
1101}
1102
1103
1104class QLastResortMimes : public QWindowsMimeConverter
1105{
1106public:
1107
1108 QLastResortMimes();
1109 // for converting from Qt
1110 bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override;
1111 bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const override;
1112 QList<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override;
1113
1114 // for converting to Qt
1115 bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override;
1116 QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override;
1117 QString mimeForFormat(const FORMATETC &formatetc) const override;
1118
1119private:
1120 mutable QMap<int, QString> formats;
1121 static QStringList ianaTypes;
1122 static QStringList excludeList;
1123};
1124
1125QStringList QLastResortMimes::ianaTypes;
1126QStringList QLastResortMimes::excludeList;
1127
1128QLastResortMimes::QLastResortMimes()
1129{
1130 //MIME Media-Types
1131 if (ianaTypes.isEmpty()) {
1132 ianaTypes.append(u"application/"_s);
1133 ianaTypes.append(u"audio/"_s);
1134 ianaTypes.append(u"example/"_s);
1135 ianaTypes.append(u"image/"_s);
1136 ianaTypes.append(u"message/"_s);
1137 ianaTypes.append(u"model/"_s);
1138 ianaTypes.append(u"multipart/"_s);
1139 ianaTypes.append(u"text/"_s);
1140 ianaTypes.append(u"video/"_s);
1141 }
1142 //Types handled by other classes
1143 if (excludeList.isEmpty()) {
1144 excludeList.append(u"HTML Format"_s);
1145 excludeList.append(u"UniformResourceLocator"_s);
1146 excludeList.append(u"text/html"_s);
1147 excludeList.append(u"text/plain"_s);
1148 excludeList.append(u"text/uri-list"_s);
1149 excludeList.append(u"application/x-qt-image"_s);
1150 excludeList.append(u"application/x-color"_s);
1151 }
1152}
1153
1154bool QLastResortMimes::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const
1155{
1156 // really check
1157#if QT_CONFIG(draganddrop)
1158 return formatetc.tymed & TYMED_HGLOBAL
1159 && (formats.contains(formatetc.cfFormat)
1160 && QInternalMimeData::hasFormatHelper(formats.value(formatetc.cfFormat), mimeData));
1161#else
1162 Q_UNUSED(mimeData);
1163 Q_UNUSED(formatetc);
1164 return formatetc.tymed & TYMED_HGLOBAL
1165 && formats.contains(formatetc.cfFormat);
1166#endif // QT_CONFIG(draganddrop)
1167}
1168
1169bool QLastResortMimes::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const
1170{
1171#if QT_CONFIG(draganddrop)
1172 return canConvertFromMime(formatetc, mimeData)
1173 && setData(QInternalMimeData::renderDataHelper(formats.value(getCf(formatetc)), mimeData), pmedium);
1174#else
1175 Q_UNUSED(mimeData);
1176 Q_UNUSED(formatetc);
1177 Q_UNUSED(pmedium);
1178 return false;
1179#endif // QT_CONFIG(draganddrop)
1180}
1181
1182QList<FORMATETC> QLastResortMimes::formatsForMime(const QString &mimeType, const QMimeData * /*mimeData*/) const
1183{
1184 QList<FORMATETC> formatetcs;
1185 auto mit = std::find(formats.begin(), formats.end(), mimeType);
1186 // register any other available formats
1187 if (mit == formats.end() && !excludeList.contains(mimeType, Qt::CaseInsensitive))
1188 mit = formats.insert(registerMimeType(mimeType), mimeType);
1189 if (mit != formats.end())
1190 formatetcs += setCf(mit.key());
1191
1192 if (!formatetcs.isEmpty())
1193 qCDebug(lcQpaMime) << __FUNCTION__ << mimeType << formatetcs;
1194 return formatetcs;
1195}
1196static const char x_qt_windows_mime[] = "application/x-qt-windows-mime;value=\"";
1197
1198static bool isCustomMimeType(const QString &mimeType)
1199{
1200 return mimeType.startsWith(QLatin1StringView(x_qt_windows_mime), Qt::CaseInsensitive);
1201}
1202
1203static QString customMimeType(const QString &mimeType, int *lindex = nullptr)
1204{
1205 int len = sizeof(x_qt_windows_mime) - 1;
1206 int n = mimeType.lastIndexOf(u'\"') - len;
1207 QString ret = mimeType.mid(len, n);
1208
1209 const int beginPos = mimeType.indexOf(u";index=");
1210 if (beginPos > -1) {
1211 const int endPos = mimeType.indexOf(u';', beginPos + 1);
1212 const int indexStartPos = beginPos + 7;
1213 if (lindex)
1214 *lindex = QStringView{mimeType}.mid(indexStartPos, endPos == -1 ? endPos : endPos - indexStartPos).toInt();
1215 } else {
1216 if (lindex)
1217 *lindex = -1;
1218 }
1219 return ret;
1220}
1221
1222bool QLastResortMimes::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const
1223{
1224 if (isCustomMimeType(mimeType)) {
1225 // MSDN documentation for QueryGetData says only -1 is supported, so ignore lindex here.
1226 QString clipFormat = customMimeType(mimeType);
1227 const UINT cf = RegisterClipboardFormat(reinterpret_cast<const wchar_t *> (clipFormat.utf16()));
1228 return canGetData(int(cf), pDataObj);
1229 }
1230 // if it is not in there then register it and see if we can get it
1231 const auto mit = std::find(formats.cbegin(), formats.cend(), mimeType);
1232 const int cf = mit != formats.cend() ? mit.key() : registerMimeType(mimeType);
1233 return canGetData(cf, pDataObj);
1234}
1235
1236QVariant QLastResortMimes::convertToMime(const QString &mimeType, IDataObject *pDataObj, QMetaType preferredType) const
1237{
1238 Q_UNUSED(preferredType);
1239 QVariant val;
1240 if (canConvertToMime(mimeType, pDataObj)) {
1241 QByteArray data;
1242 if (isCustomMimeType(mimeType)) {
1243 int lindex;
1244 QString clipFormat = customMimeType(mimeType, &lindex);
1245 const UINT cf = RegisterClipboardFormat(reinterpret_cast<const wchar_t *> (clipFormat.utf16()));
1246 data = getData(int(cf), pDataObj, lindex);
1247 } else {
1248 const auto mit = std::find(formats.cbegin(), formats.cend(), mimeType);
1249 const int cf = mit != formats.cend() ? mit.key() : registerMimeType(mimeType);
1250 data = getData(cf, pDataObj);
1251 }
1252 if (!data.isEmpty())
1253 val = data; // it should be enough to return the data and let QMimeData do the rest.
1254 }
1255 return val;
1256}
1257
1258QString QLastResortMimes::mimeForFormat(const FORMATETC &formatetc) const
1259{
1260 QString format = formats.value(getCf(formatetc));
1261 if (!format.isEmpty())
1262 return format;
1263
1264 const QString clipFormat = QWindowsMimeRegistry::clipboardFormatName(getCf(formatetc));
1265 if (!clipFormat.isEmpty()) {
1266#if QT_CONFIG(draganddrop)
1267 if (QInternalMimeData::canReadData(clipFormat))
1268 format = clipFormat;
1269 else if ((formatetc.cfFormat >= 0xC000)){
1270 //create the mime as custom. not registered.
1271 if (!excludeList.contains(clipFormat, Qt::CaseInsensitive)) {
1272 //check if this is a mime type
1273 bool ianaType = false;
1274 int sz = ianaTypes.size();
1275 for (int i = 0; i < sz; i++) {
1276 if (clipFormat.startsWith(ianaTypes[i], Qt::CaseInsensitive)) {
1277 ianaType = true;
1278 break;
1279 }
1280 }
1281 if (!ianaType)
1282 format = QLatin1StringView(x_qt_windows_mime) + clipFormat + u'"';
1283 else
1284 format = clipFormat;
1285 }
1286 }
1287#endif // QT_CONFIG(draganddrop)
1288 }
1289
1290 return format;
1291}
1292
1293/*!
1294 \class QWindowsMimeRegistry
1295 \brief Manages the list of QWindowsMimeConverter instances.
1296 \internal
1297 \sa QWindowsMimeConverter
1298*/
1299
1300QWindowsMimeRegistry::QWindowsMimeRegistry() = default;
1301
1302QWindowsMimeRegistry::~QWindowsMimeRegistry()
1303{
1304 qDeleteAll(m_mimes.begin(), m_mimes.begin() + m_internalMimeCount);
1305}
1306
1307QWindowsMimeRegistry::QWindowsMimeConverter *QWindowsMimeRegistry::converterToMime(const QString &mimeType, IDataObject *pDataObj) const
1308{
1309 ensureInitialized();
1310 for (int i = m_mimes.size()-1; i >= 0; --i) {
1311 if (m_mimes.at(i)->canConvertToMime(mimeType, pDataObj))
1312 return m_mimes.at(i);
1313 }
1314 return nullptr;
1315}
1316
1317QStringList QWindowsMimeRegistry::allMimesForFormats(IDataObject *pDataObj) const
1318{
1319 qCDebug(lcQpaMime) << "QWindowsMimeConverter::allMimesForFormats()";
1320 ensureInitialized();
1321 QStringList formats;
1322 LPENUMFORMATETC FAR fmtenum;
1323 HRESULT hr = pDataObj->EnumFormatEtc(DATADIR_GET, &fmtenum);
1324
1325 if (hr == NOERROR) {
1326 FORMATETC fmtetc;
1327 while (S_OK == fmtenum->Next(1, &fmtetc, nullptr)) {
1328 for (int i= m_mimes.size() - 1; i >= 0; --i) {
1329 QString format = m_mimes.at(i)->mimeForFormat(fmtetc);
1330 if (!format.isEmpty() && !formats.contains(format)) {
1331 formats += format;
1332 if (QWindowsContext::verbose > 1 && lcQpaMime().isDebugEnabled())
1333 qCDebug(lcQpaMime) << __FUNCTION__ << fmtetc << format;
1334 }
1335 }
1336 // as documented in MSDN to avoid possible memleak
1337 if (fmtetc.ptd)
1338 CoTaskMemFree(fmtetc.ptd);
1339 }
1340 fmtenum->Release();
1341 }
1342 qCDebug(lcQpaMime) << pDataObj << formats;
1343 return formats;
1344}
1345
1346QWindowsMimeRegistry::QWindowsMimeConverter *QWindowsMimeRegistry::converterFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const
1347{
1348 ensureInitialized();
1349 qCDebug(lcQpaMime) << __FUNCTION__ << formatetc;
1350 for (int i = m_mimes.size()-1; i >= 0; --i) {
1351 if (m_mimes.at(i)->canConvertFromMime(formatetc, mimeData))
1352 return m_mimes.at(i);
1353 }
1354 return nullptr;
1355}
1356
1357QList<FORMATETC> QWindowsMimeRegistry::allFormatsForMime(const QMimeData *mimeData) const
1358{
1359 ensureInitialized();
1360 QList<FORMATETC> formatics;
1361#if !QT_CONFIG(draganddrop)
1362 Q_UNUSED(mimeData);
1363#else
1364 formatics.reserve(20);
1365 const QStringList formats = QInternalMimeData::formatsHelper(mimeData);
1366 for (int f = 0; f < formats.size(); ++f) {
1367 for (int i = m_mimes.size() - 1; i >= 0; --i)
1368 formatics += m_mimes.at(i)->formatsForMime(formats.at(f), mimeData);
1369 }
1370#endif // QT_CONFIG(draganddrop)
1371 return formatics;
1372}
1373
1374void QWindowsMimeRegistry::ensureInitialized() const
1375{
1376 if (m_internalMimeCount == 0) {
1377 m_internalMimeCount = -1; // prevent reentrancy when types register themselves
1378#if QT_CONFIG(imageformat_bmp)
1379 (void)new QWindowsMimeImage;
1380#endif //QT_CONFIG(imageformat_bmp)
1381 (void)new QLastResortMimes;
1382 (void)new QWindowsMimeText;
1383 (void)new QWindowsMimeURI;
1384 (void)new QWindowsMimeHtml;
1385 (void)new QBuiltInMimes;
1386 m_internalMimeCount = m_mimes.size();
1387 Q_ASSERT(m_internalMimeCount > 0);
1388 }
1389}
1390
1391QString QWindowsMimeRegistry::clipboardFormatName(int cf)
1392{
1393 wchar_t buf[256] = {0};
1394 return GetClipboardFormatName(UINT(cf), buf, 255)
1395 ? QString::fromWCharArray(buf) : QString();
1396}
1397
1398QVariant QWindowsMimeRegistry::convertToMime(const QStringList &mimeTypes,
1399 IDataObject *pDataObj,
1400 QMetaType preferredType,
1401 QString *formatIn /* = 0 */) const
1402{
1403 for (const QString &format : mimeTypes) {
1404 if (const QWindowsMimeConverter *converter = converterToMime(format, pDataObj)) {
1405 if (converter->canConvertToMime(format, pDataObj)) {
1406 const QVariant dataV = converter->convertToMime(format, pDataObj, preferredType);
1407 if (dataV.isValid()) {
1408 qCDebug(lcQpaMime) << __FUNCTION__ << mimeTypes << "\nFormat: "
1409 << format << pDataObj << " returns " << dataV;
1410 if (formatIn)
1411 *formatIn = format;
1412 return dataV;
1413 }
1414 }
1415 }
1416 }
1417 qCDebug(lcQpaMime) << __FUNCTION__ << "fails" << mimeTypes << pDataObj << preferredType.id();
1418 return QVariant();
1419}
1420
1421void QWindowsMimeRegistry::registerMime(QWindowsMimeConverter *mime)
1422{
1423 ensureInitialized();
1424 m_mimes.append(mime);
1425}
1426
1427/*!
1428 Registers the MIME type \a mime, and returns an ID number
1429 identifying the format on Windows.
1430
1431 A mime type \c {application/x-qt-windows-mime;value="WindowsType"} will be
1432 registered as the clipboard format for \c WindowsType.
1433*/
1434int QWindowsMimeRegistry::registerMimeType(const QString &mime)
1435{
1436 const QString mimeType = isCustomMimeType(mime) ? customMimeType(mime) : mime;
1437 const UINT f = RegisterClipboardFormat(reinterpret_cast<const wchar_t *> (mimeType.utf16()));
1438 if (!f) {
1439 qErrnoWarning("QWindowsMimeRegistry::registerMimeType: Failed to register clipboard format "
1440 "for %s", qPrintable(mime));
1441 }
1442
1443 return int(f);
1444}
1445
1446QT_END_NAMESPACE
QBuiltInMimes::formatsForMime
QList< FORMATETC > formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override
Returns a QList of FORMATETC structures representing the different windows clipboard formats that can...
Definition qwindowsmimeregistry.cpp:1065
QBuiltInMimes::canConvertToMime
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override
Returns true if the converter can convert to the mimeType from the available formats in pDataObj.
Definition qwindowsmimeregistry.cpp:1074
QBuiltInMimes::mimeForFormat
QString mimeForFormat(const FORMATETC &formatetc) const override
Returns the mime type that will be created form the format specified in formatetc,...
Definition qwindowsmimeregistry.cpp:1098
QBuiltInMimes::convertFromMime
bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override
Convert the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:1018
QBuiltInMimes::convertToMime
QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override
Returns a QVariant containing the converted data for mimeType from pDataObj.
Definition qwindowsmimeregistry.cpp:1080
QBuiltInMimes::canConvertFromMime
bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override
Returns true if the converter can convert from the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:1010
QLastResortMimes::mimeForFormat
QString mimeForFormat(const FORMATETC &formatetc) const override
Returns the mime type that will be created form the format specified in formatetc,...
Definition qwindowsmimeregistry.cpp:1258
QLastResortMimes::formatsForMime
QList< FORMATETC > formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override
Returns a QList of FORMATETC structures representing the different windows clipboard formats that can...
Definition qwindowsmimeregistry.cpp:1182
QLastResortMimes::canConvertToMime
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override
Returns true if the converter can convert to the mimeType from the available formats in pDataObj.
Definition qwindowsmimeregistry.cpp:1222
QLastResortMimes::convertToMime
QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override
Returns a QVariant containing the converted data for mimeType from pDataObj.
Definition qwindowsmimeregistry.cpp:1236
QLastResortMimes::convertFromMime
bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override
Convert the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:1169
QLastResortMimes::canConvertFromMime
bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override
Returns true if the converter can convert from the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:1154
QWindowsContext
Singleton container for all relevant information.
Definition qwindowscontext.h:50
QWindowsMimeHtml::canConvertFromMime
bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override
Returns true if the converter can convert from the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:734
QWindowsMimeHtml::convertFromMime
bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override
Convert the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:790
QWindowsMimeHtml::mimeForFormat
QString mimeForFormat(const FORMATETC &formatetc) const override
Returns the mime type that will be created form the format specified in formatetc,...
Definition qwindowsmimeregistry.cpp:721
QWindowsMimeHtml::canConvertToMime
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override
Returns true if the converter can convert to the mimeType from the available formats in pDataObj.
Definition qwindowsmimeregistry.cpp:728
QWindowsMimeHtml::convertToMime
QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QMetaType preferredType) const override
Returns a QVariant containing the converted data for mimeType from pDataObj.
Definition qwindowsmimeregistry.cpp:751
QWindowsMimeHtml::formatsForMime
QList< FORMATETC > formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override
Returns a QList of FORMATETC structures representing the different windows clipboard formats that can...
Definition qwindowsmimeregistry.cpp:713
QWindowsMimeRegistry
Manages the list of QWindowsMimeConverter instances.
Definition qwindowsmimeregistry.h:21
QWindowsMimeRegistry::convertToMime
QVariant convertToMime(const QStringList &mimeTypes, IDataObject *pDataObj, QMetaType preferredType, QString *format=nullptr) const
Definition qwindowsmimeregistry.cpp:1398
QWindowsMimeRegistry::converterFromMime
QWindowsMimeConverter * converterFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const
Definition qwindowsmimeregistry.cpp:1346
QWindowsMimeRegistry::registerMime
void registerMime(QWindowsMimeConverter *mime)
Definition qwindowsmimeregistry.cpp:1421
QWindowsMimeRegistry::allMimesForFormats
QStringList allMimesForFormats(IDataObject *pDataObj) const
Definition qwindowsmimeregistry.cpp:1317
QWindowsMimeRegistry::allFormatsForMime
QList< FORMATETC > allFormatsForMime(const QMimeData *mimeData) const
Definition qwindowsmimeregistry.cpp:1357
QWindowsMimeRegistry::converterToMime
QWindowsMimeConverter * converterToMime(const QString &mimeType, IDataObject *pDataObj) const
Definition qwindowsmimeregistry.cpp:1307
QWindowsMimeText::canConvertToMime
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override
Returns true if the converter can convert to the mimeType from the available formats in pDataObj.
Definition qwindowsmimeregistry.cpp:460
QWindowsMimeText::canConvertFromMime
bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override
Returns true if the converter can convert from the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:377
QWindowsMimeText::convertToMime
QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QMetaType preferredType) const override
Definition qwindowsmimeregistry.cpp:487
QWindowsMimeText::convertFromMime
bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override
Convert the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:388
QWindowsMimeText::formatsForMime
QList< FORMATETC > formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override
Returns a QList of FORMATETC structures representing the different windows clipboard formats that can...
Definition qwindowsmimeregistry.cpp:476
QWindowsMimeText::mimeForFormat
QString mimeForFormat(const FORMATETC &formatetc) const override
Returns the mime type that will be created form the format specified in formatetc,...
Definition qwindowsmimeregistry.cpp:467
QWindowsMimeURI::formatsForMime
QList< FORMATETC > formatsForMime(const QString &mimeType, const QMimeData *mimeData) const override
Returns a QList of FORMATETC structures representing the different windows clipboard formats that can...
Definition qwindowsmimeregistry.cpp:628
QWindowsMimeURI::mimeForFormat
QString mimeForFormat(const FORMATETC &formatetc) const override
Returns the mime type that will be created form the format specified in formatetc,...
Definition qwindowsmimeregistry.cpp:620
QWindowsMimeURI::canConvertToMime
bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const override
Returns true if the converter can convert to the mimeType from the available formats in pDataObj.
Definition qwindowsmimeregistry.cpp:614
QWindowsMimeURI::convertToMime
QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QMetaType preferredType) const override
Definition qwindowsmimeregistry.cpp:642
QWindowsMimeURI::canConvertFromMime
bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const override
Returns true if the converter can convert from the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:544
QWindowsMimeURI::convertFromMime
bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const override
Convert the mimeData to the format specified in formatetc.
Definition qwindowsmimeregistry.cpp:556
msgConversionError
static QByteArray msgConversionError(const char *func, const char *format)
Definition qwindowsmimeregistry.cpp:69
x_qt_windows_mime
static const char x_qt_windows_mime[]
Definition qwindowsmimeregistry.cpp:1196
canGetData
static bool canGetData(int cf, IDataObject *pDataObj)
Definition qwindowsmimeregistry.cpp:291
setData
static bool setData(const QByteArray &data, STGMEDIUM *pmedium, DWORD tymed=TYMED_HGLOBAL)
Definition qwindowsmimeregistry.cpp:213
setCf
static FORMATETC setCf(int cf)
Definition qwindowsmimeregistry.cpp:202
isCustomMimeType
static bool isCustomMimeType(const QString &mimeType)
Definition qwindowsmimeregistry.cpp:1198
getData
static QByteArray getData(int cf, IDataObject *pDataObj, int lindex=-1)
Definition qwindowsmimeregistry.cpp:247
customMimeType
static QString customMimeType(const QString &mimeType, int *lindex=nullptr)
Definition qwindowsmimeregistry.cpp:1203
readDib
static bool readDib(QBuffer &buffer, QImage &img)
Definition qwindowsmimeregistry.cpp:83
getCf
static int getCf(const FORMATETC &formatetc)
Definition qwindowsmimeregistry.cpp:197
dibFormatC
static const char dibFormatC[]
Definition qwindowsmimeregistry.cpp:67
BMP_BITMAPV5HEADER
Definition qwindowsmimeregistry.cpp:40
BMP_BITMAPV5HEADER::bV5BitCount
WORD bV5BitCount
Definition qwindowsmimeregistry.cpp:45
BMP_BITMAPV5HEADER::bV5Size
DWORD bV5Size
Definition qwindowsmimeregistry.cpp:41
BMP_BITMAPV5HEADER::bV5Planes
WORD bV5Planes
Definition qwindowsmimeregistry.cpp:44
BMP_BITMAPV5HEADER::bV5SizeImage
DWORD bV5SizeImage
Definition qwindowsmimeregistry.cpp:47
BMP_BITMAPV5HEADER::bV5Reserved
DWORD bV5Reserved
Definition qwindowsmimeregistry.cpp:64
BMP_BITMAPV5HEADER::bV5ClrUsed
DWORD bV5ClrUsed
Definition qwindowsmimeregistry.cpp:50
BMP_BITMAPV5HEADER::bV5RedMask
DWORD bV5RedMask
Definition qwindowsmimeregistry.cpp:52
BMP_BITMAPV5HEADER::bV5GreenMask
DWORD bV5GreenMask
Definition qwindowsmimeregistry.cpp:53
BMP_BITMAPV5HEADER::bV5BlueMask
DWORD bV5BlueMask
Definition qwindowsmimeregistry.cpp:54
BMP_BITMAPV5HEADER::bV5GammaRed
DWORD bV5GammaRed
Definition qwindowsmimeregistry.cpp:58
BMP_BITMAPV5HEADER::bV5YPelsPerMeter
LONG bV5YPelsPerMeter
Definition qwindowsmimeregistry.cpp:49
BMP_BITMAPV5HEADER::bV5Compression
DWORD bV5Compression
Definition qwindowsmimeregistry.cpp:46
BMP_BITMAPV5HEADER::bV5Intent
DWORD bV5Intent
Definition qwindowsmimeregistry.cpp:61
BMP_BITMAPV5HEADER::bV5GammaBlue
DWORD bV5GammaBlue
Definition qwindowsmimeregistry.cpp:60
BMP_BITMAPV5HEADER::bV5Height
LONG bV5Height
Definition qwindowsmimeregistry.cpp:43
BMP_BITMAPV5HEADER::bV5Endpoints
_CIEXYZTRIPLE bV5Endpoints
Definition qwindowsmimeregistry.cpp:57
BMP_BITMAPV5HEADER::bV5AlphaMask
DWORD bV5AlphaMask
Definition qwindowsmimeregistry.cpp:55
BMP_BITMAPV5HEADER::bV5Width
LONG bV5Width
Definition qwindowsmimeregistry.cpp:42
BMP_BITMAPV5HEADER::bV5ClrImportant
DWORD bV5ClrImportant
Definition qwindowsmimeregistry.cpp:51
BMP_BITMAPV5HEADER::bV5GammaGreen
DWORD bV5GammaGreen
Definition qwindowsmimeregistry.cpp:59
BMP_BITMAPV5HEADER::bV5ProfileSize
DWORD bV5ProfileSize
Definition qwindowsmimeregistry.cpp:63
BMP_BITMAPV5HEADER::bV5XPelsPerMeter
LONG bV5XPelsPerMeter
Definition qwindowsmimeregistry.cpp:48
BMP_BITMAPV5HEADER::bV5ProfileData
DWORD bV5ProfileData
Definition qwindowsmimeregistry.cpp:62
BMP_BITMAPV5HEADER::bV5CSType
DWORD bV5CSType
Definition qwindowsmimeregistry.cpp:56
_CIEXYZTRIPLE
Definition qwindowsmimeregistry.cpp:36
_CIEXYZTRIPLE::ciexyzRed
_CIEXYZ ciexyzRed
Definition qwindowsmimeregistry.cpp:37
_CIEXYZTRIPLE::ciexyzGreen
_CIEXYZ ciexyzGreen
Definition qwindowsmimeregistry.cpp:37
_CIEXYZTRIPLE::ciexyzBlue
_CIEXYZ ciexyzBlue
Definition qwindowsmimeregistry.cpp:37
_CIEXYZ
Definition qwindowsmimeregistry.cpp:32
_CIEXYZ::ciexyzX
long ciexyzX
Definition qwindowsmimeregistry.cpp:33
_CIEXYZ::ciexyzY
long ciexyzY
Definition qwindowsmimeregistry.cpp:33
_CIEXYZ::ciexyzZ
long ciexyzZ
Definition qwindowsmimeregistry.cpp:33