1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qmime.h"

    43 

    44 #include "qimagereader.h"

    45 #include "qimagewriter.h"

    46 #include "qdatastream.h"

    47 #include "qbuffer.h"

    48 #include "qt_windows.h"

    49 #include "qapplication_p.h"

    50 #include "qtextcodec.h"

    51 #include "qregexp.h"

    52 #include "qalgorithms.h"

    53 #include "qmap.h"

    54 #include "qdnd_p.h"

    55 #include <shlobj.h>

    56 #include "qurl.h"

    57 #include "qvariant.h"

    58 #include "qtextdocument.h"

    59 #include "qdir.h"

    60 

    61 #if defined(Q_OS_WINCE)

    62 #include "qguifunctions_wince.h"

    63 #endif

    64 

    65 QT_BEGIN_NAMESPACE

    66 

    67 #ifndef QT_NO_IMAGEFORMAT_BMP

    68 #ifndef CF_DIBV5

    69 #define CF_DIBV5 17

    70 #endif

    71 /* The MSVC compilers allows multi-byte characters, that has the behavior of

    72  * that each character gets shifted into position. 0x73524742 below is for MSVC

    73  * equivalent to doing 'sRGB', but this does of course not work

    74  * on conformant C++ compilers. */

    75 #define BMP_LCS_sRGB  0x73524742

    76 #define BMP_LCS_GM_IMAGES  0x00000004L

    77 

    78 struct _CIEXYZ {

    79     long ciexyzX, ciexyzY, ciexyzZ;

    80 };

    81 

    82 struct _CIEXYZTRIPLE {

    83     _CIEXYZ  ciexyzRed, ciexyzGreen, ciexyzBlue;

    84 };

    85 

    86 struct BMP_BITMAPV5HEADER {

    87     DWORD  bV5Size;

    88     LONG   bV5Width;

    89     LONG   bV5Height;

    90     WORD   bV5Planes;

    91     WORD   bV5BitCount;

    92     DWORD  bV5Compression;

    93     DWORD  bV5SizeImage;

    94     LONG   bV5XPelsPerMeter;

    95     LONG   bV5YPelsPerMeter;

    96     DWORD  bV5ClrUsed;

    97     DWORD  bV5ClrImportant;

    98     DWORD  bV5RedMask;

    99     DWORD  bV5GreenMask;

   100     DWORD  bV5BlueMask;

   101     DWORD  bV5AlphaMask;

   102     DWORD  bV5CSType;

   103     _CIEXYZTRIPLE bV5Endpoints;

   104     DWORD  bV5GammaRed;

   105     DWORD  bV5GammaGreen;

   106     DWORD  bV5GammaBlue;

   107     DWORD  bV5Intent;

   108     DWORD  bV5ProfileData;

   109     DWORD  bV5ProfileSize;

   110     DWORD  bV5Reserved;

   111 };

   112 static const int BMP_BITFIELDS = 3;

   113 

   114 extern bool qt_read_dib(QDataStream&, QImage&); // qimage.cpp

   115 extern bool qt_write_dib(QDataStream&, QImage);   // qimage.cpp

   116 static bool qt_write_dibv5(QDataStream &s, QImage image);

   117 static bool qt_read_dibv5(QDataStream &s, QImage &image);

   118 #endif

   119 

   120 //#define QMIME_DEBUG

   121 

   122 

   123 // helpers for using global memory

   124 

   125 static int getCf(const FORMATETC &formatetc)

   126 {

   127     return formatetc.cfFormat;

   128 }

   129 

   130 static FORMATETC setCf(int cf)

   131 {

   132     FORMATETC formatetc;

   133     formatetc.cfFormat = cf;

   134     formatetc.dwAspect = DVASPECT_CONTENT;

   135     formatetc.lindex = -1;

   136     formatetc.ptd = NULL;

   137     formatetc.tymed = TYMED_HGLOBAL;

   138     return formatetc;

   139 }

   140 

   141 static bool setData(const QByteArray &data, STGMEDIUM *pmedium)

   142 {

   143     HGLOBAL hData = GlobalAlloc(0, data.size());

   144     if (!hData)

   145         return false;

   146 

   147     void *out = GlobalLock(hData);

   148     memcpy(out, data.data(), data.size());

   149     GlobalUnlock(hData);

   150     pmedium->tymed = TYMED_HGLOBAL;

   151     pmedium->hGlobal = hData;

   152     pmedium->pUnkForRelease = 0;

   153     return true;

   154 }

   155 

   156 static QByteArray getData(int cf, IDataObject *pDataObj)

   157 {

   158     QByteArray data;

   159     FORMATETC formatetc = setCf(cf);

   160     STGMEDIUM s;

   161     if (pDataObj->GetData(&formatetc, &s) == S_OK) {

   162         DWORD * val = (DWORD*)GlobalLock(s.hGlobal);

   163         data = QByteArray::fromRawData((char*)val, GlobalSize(s.hGlobal));

   164         data.detach();

   165         GlobalUnlock(s.hGlobal);

   166         ReleaseStgMedium(&s);

   167     } else  {

   168         //Try reading IStream data

   169         formatetc.tymed = TYMED_ISTREAM;

   170         if (pDataObj->GetData(&formatetc, &s) == S_OK) {

   171             char szBuffer[4096];

   172             ULONG actualRead = 0;

   173             LARGE_INTEGER pos = {{0, 0}};

   174             //Move to front (can fail depending on the data model implemented)

   175             HRESULT hr = s.pstm->Seek(pos, STREAM_SEEK_SET, NULL);

   176             while(SUCCEEDED(hr)){

   177                 hr = s.pstm->Read(szBuffer, sizeof(szBuffer), &actualRead);

   178                 if (SUCCEEDED(hr) && actualRead > 0) {

   179                     data += QByteArray::fromRawData(szBuffer, actualRead);

   180                 }

   181                 if (actualRead != sizeof(szBuffer))

   182                     break;

   183             }

   184             data.detach();

   185             ReleaseStgMedium(&s);

   186         }

   187     }

   188     return data;

   189 }

   190 

   191 static bool canGetData(int cf, IDataObject * pDataObj)

   192 {

   193     FORMATETC formatetc = setCf(cf);

   194      if (pDataObj->QueryGetData(&formatetc) != S_OK){

   195         formatetc.tymed = TYMED_ISTREAM;

   196         return pDataObj->QueryGetData(&formatetc) == S_OK;

   197     }

   198     return true;

   199 }

   200 

   201 class QWindowsMimeList

   202 {

   203 public:

   204     QWindowsMimeList();

   205     ~QWindowsMimeList();

   206     void addWindowsMime(QWindowsMime * mime);

   207     void removeWindowsMime(QWindowsMime * mime);

   208     QList<QWindowsMime*> windowsMimes();

   209 

   210 private:

   211     void init();

   212     bool initialized;

   213     QList<QWindowsMime*> mimes;

   214 };

   215 

   216 Q_GLOBAL_STATIC(QWindowsMimeList, theMimeList);

   217 

   218 

   219 /*!

   220     \class QWindowsMime

   221     \brief The QWindowsMime class maps open-standard MIME to Window Clipboard formats.

   222     \ingroup draganddrop

   223 

   224     Qt's drag-and-drop and clipboard facilities use the MIME standard.

   225     On X11, this maps trivially to the Xdnd protocol, but on Windows

   226     although some applications use MIME types to describe clipboard

   227     formats, others use arbitrary non-standardized naming conventions,

   228     or unnamed built-in formats of Windows.

   229 

   230     By instantiating subclasses of QWindowsMime that provide conversions

   231     between Windows Clipboard and MIME formats, you can convert

   232     proprietary clipboard formats to MIME formats.

   233 

   234     Qt has predefined support for the following Windows Clipboard formats:

   235 

   236     \table

   237     \header \o Windows Format \o Equivalent MIME type

   238     \row \o \c CF_UNICODETEXT \o \c text/plain

   239     \row \o \c CF_TEXT        \o \c text/plain

   240     \row \o \c CF_DIB         \o \c{image/xyz}, where \c xyz is

   241                                  a \l{QImageWriter::supportedImageFormats()}{Qt image format}

   242     \row \o \c CF_HDROP       \o \c text/uri-list

   243     \row \o \c CF_INETURL     \o \c text/uri-list

   244     \row \o \c CF_HTML        \o \c text/html

   245     \endtable

   246 

   247     An example use of this class would be to map the Windows Metafile

   248     clipboard format (\c CF_METAFILEPICT) to and from the MIME type

   249     \c{image/x-wmf}. This conversion might simply be adding or removing

   250     a header, or even just passing on the data. See \l{Drag and Drop}

   251     for more information on choosing and definition MIME types.

   252 

   253     You can check if a MIME type is convertible using canConvertFromMime() and

   254     can perform conversions with convertToMime() and convertFromMime().

   255 */

   256 

   257 /*!

   258 Constructs a new conversion object, adding it to the globally accessed

   259 list of available converters.

   260 */

   261 QWindowsMime::QWindowsMime()

   262 {

   263     theMimeList()->addWindowsMime(this);

   264 }

   265 

   266 /*!

   267 Destroys a conversion object, removing it from the global

   268 list of available converters.

   269 */

   270 QWindowsMime::~QWindowsMime()

   271 {

   272     theMimeList()->removeWindowsMime(this);

   273 }

   274 

   275 

   276 /*!

   277     Registers the MIME type \a mime, and returns an ID number

   278     identifying the format on Windows.

   279 */

   280 int QWindowsMime::registerMimeType(const QString &mime)

   281 {

   282     int f = RegisterClipboardFormat(reinterpret_cast<const wchar_t *> (mime.utf16()));

   283     if (!f)

   284         qErrnoWarning("QWindowsMime::registerMimeType: Failed to register clipboard format");

   285 

   286     return f;

   287 }

   288 

   289 

   290 /*!

   291 \fn bool QWindowsMime::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const

   292 

   293   Returns true if the converter can convert from the \a mimeData to

   294   the format specified in \a formatetc.

   295 

   296   All subclasses must reimplement this pure virtual function.

   297 */

   298 

   299 /*!

   300   \fn bool QWindowsMime::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const

   301 

   302   Returns true if the converter can convert to the \a mimeType from

   303   the available formats in \a pDataObj.

   304 

   305   All subclasses must reimplement this pure virtual function.

   306 */

   307 

   308 /*!

   309 \fn QString QWindowsMime::mimeForFormat(const FORMATETC &formatetc) const

   310 

   311   Returns the mime type that will be created form the format specified

   312   in \a formatetc, or an empty string if this converter does not support

   313   \a formatetc.

   314 

   315   All subclasses must reimplement this pure virtual function.

   316 */

   317 

   318 /*!

   319 \fn QVector<FORMATETC> QWindowsMime::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const

   320 

   321   Returns a QVector of FORMATETC structures representing the different windows clipboard

   322   formats that can be provided for the \a mimeType from the \a mimeData.

   323 

   324   All subclasses must reimplement this pure virtual function.

   325 */

   326 

   327 /*!

   328     \fn QVariant QWindowsMime::convertToMime(const QString &mimeType, IDataObject *pDataObj,

   329                                              QVariant::Type preferredType) const

   330 

   331     Returns a QVariant containing the converted data for \a mimeType from \a pDataObj.

   332     If possible the QVariant should be of the \a preferredType to avoid needless conversions.

   333 

   334     All subclasses must reimplement this pure virtual function.

   335 */

   336 

   337 /*!

   338 \fn bool QWindowsMime::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const

   339 

   340   Convert the \a mimeData to the format specified in \a formatetc.

   341   The converted data should then be placed in \a pmedium structure.

   342 

   343   Return true if the conversion was successful.

   344 

   345   All subclasses must reimplement this pure virtual function.

   346 */

   347 

   348 

   349 QWindowsMime *QWindowsMime::converterFromMime(const FORMATETC &formatetc, const QMimeData *mimeData)

   350 {

   351     QList<QWindowsMime*> mimes = theMimeList()->windowsMimes();

   352     for (int i=mimes.size()-1; i>=0; --i) {

   353         if (mimes.at(i)->canConvertFromMime(formatetc, mimeData))

   354             return mimes.at(i);

   355     }

   356     return 0;

   357 }

   358 

   359 QWindowsMime *QWindowsMime::converterToMime(const QString &mimeType, IDataObject *pDataObj)

   360 {

   361     QList<QWindowsMime*> mimes = theMimeList()->windowsMimes();

   362     for (int i=mimes.size()-1; i>=0; --i) {

   363         if (mimes.at(i)->canConvertToMime(mimeType, pDataObj))

   364             return mimes.at(i);

   365     }

   366     return 0;

   367 }

   368 

   369 QVector<FORMATETC> QWindowsMime::allFormatsForMime(const QMimeData *mimeData)

   370 {

   371     QList<QWindowsMime*> mimes = theMimeList()->windowsMimes();

   372     QVector<FORMATETC> formatics;

   373     formatics.reserve(20);

   374 #ifndef QT_NO_DRAGANDDROP

   375     QStringList formats = QInternalMimeData::formatsHelper(mimeData);

   376     for (int f=0; f<formats.size(); ++f) {

   377         for (int i=mimes.size()-1; i>=0; --i)

   378             formatics += mimes.at(i)->formatsForMime(formats.at(f), mimeData);

   379     }

   380 #else

   381     Q_UNUSED(mimeData);

   382 #endif //QT_NO_DRAGANDDROP

   383     return formatics;

   384 }

   385 

   386 QStringList QWindowsMime::allMimesForFormats(IDataObject *pDataObj)

   387 {

   388     QList<QWindowsMime*> mimes = theMimeList()->windowsMimes();

   389     QStringList formats;

   390     LPENUMFORMATETC FAR fmtenum;

   391     HRESULT hr = pDataObj->EnumFormatEtc(DATADIR_GET, &fmtenum);

   392 

   393     if (hr == NOERROR) {

   394         FORMATETC fmtetc;

   395         while (S_OK == fmtenum->Next(1, &fmtetc, 0)) {

   396 #if defined(QMIME_DEBUG) && !defined(Q_OS_WINCE)

   397             qDebug("QWindowsMime::allMimesForFormats()");

   398             wchar_t buf[256] = {0};

   399             GetClipboardFormatName(fmtetc.cfFormat, buf, 255);

   400             qDebug("CF = %d : %s", fmtetc.cfFormat, QString::fromWCharArray(buf));

   401 #endif

   402             for (int i=mimes.size()-1; i>=0; --i) {

   403                 QString format = mimes.at(i)->mimeForFormat(fmtetc);

   404                 if (!format.isEmpty() && !formats.contains(format)) {

   405                     formats += format;

   406                 }

   407             }

   408             // as documented in MSDN to avoid possible memleak

   409             if (fmtetc.ptd)

   410                 CoTaskMemFree(fmtetc.ptd);

   411         }

   412         fmtenum->Release();

   413     }

   414 

   415     return formats;

   416 }

   417 

   418 

   419 class QWindowsMimeText : public QWindowsMime

   420 {

   421 public:

   422     bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const;

   423     QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QVariant::Type preferredType) const;

   424     QString mimeForFormat(const FORMATETC &formatetc) const;

   425     bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const;

   426     bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const;

   427     QVector<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const;

   428 };

   429 

   430 bool QWindowsMimeText::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const

   431 {

   432     int cf = getCf(formatetc);

   433     return (cf == CF_UNICODETEXT || cf == CF_TEXT) && mimeData->hasText();

   434 }

   435 

   436 /*

   437 text/plain is defined as using CRLF, but so many programs don't,

   438 and programmers just look for '\n' in strings.

   439 Windows really needs CRLF, so we ensure it here.

   440 */

   441 bool QWindowsMimeText::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const

   442 {

   443     if (canConvertFromMime(formatetc, mimeData)) {

   444         QByteArray data;

   445         int cf = getCf(formatetc);

   446         if (cf == CF_TEXT) {

   447             data = mimeData->text().toLocal8Bit();

   448             // Anticipate required space for CRLFs at 1/40

   449             int maxsize=data.size()+data.size()/40+3;

   450             QByteArray r(maxsize, '\0');

   451             char* o = r.data();

   452             const char* d = data.data();

   453             const int s = data.size();

   454             bool cr=false;

   455             int j=0;

   456             for (int i=0; i<s; i++) {

   457                 char c = d[i];

   458                 if (c=='\r')

   459                     cr=true;

   460                 else {

   461                     if (c=='\n') {

   462                         if (!cr)

   463                             o[j++]='\r';

   464                     }

   465                     cr=false;

   466                 }

   467                 o[j++]=c;

   468                 if (j+3 >= maxsize) {

   469                     maxsize += maxsize/4;

   470                     r.resize(maxsize);

   471                     o = r.data();

   472                 }

   473             }

   474             o[j]=0;

   475             return setData(r, pmedium);

   476         } else if (cf == CF_UNICODETEXT) {

   477             QString str = mimeData->text();

   478             const QChar *u = str.unicode();

   479             QString res;

   480             const int s = str.length();

   481             int maxsize = s + s/40 + 3;

   482             res.resize(maxsize);

   483             int ri = 0;

   484             bool cr = false;

   485             for (int i=0; i < s; ++i) {

   486                 if (*u == QLatin1Char('\r'))

   487                     cr = true;

   488                 else {

   489                     if (*u == QLatin1Char('\n') && !cr)

   490                         res[ri++] = QLatin1Char('\r');

   491                     cr = false;

   492                 }

   493                 res[ri++] = *u;

   494                 if (ri+3 >= maxsize) {

   495                     maxsize += maxsize/4;

   496                     res.resize(maxsize);

   497                 }

   498                 ++u;

   499             }

   500             res.truncate(ri);

   501             const int byteLength = res.length() * sizeof(ushort);

   502             QByteArray r(byteLength + 2, '\0');

   503             memcpy(r.data(), res.unicode(), byteLength);

   504             r[byteLength] = 0;

   505             r[byteLength+1] = 0;

   506             return setData(r, pmedium);

   507         }

   508     }

   509     return false;

   510 }

   511 

   512 bool QWindowsMimeText::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const

   513 {

   514     return mimeType.startsWith(QLatin1String("text/plain"))

   515            && (canGetData(CF_UNICODETEXT, pDataObj)

   516            || canGetData(CF_TEXT, pDataObj));

   517 }

   518 

   519 QString QWindowsMimeText::mimeForFormat(const FORMATETC &formatetc) const

   520 {

   521     int cf = getCf(formatetc);

   522     if (cf == CF_UNICODETEXT || cf == CF_TEXT)

   523         return QLatin1String("text/plain");

   524     return QString();

   525 }

   526 

   527 

   528 QVector<FORMATETC> QWindowsMimeText::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const

   529 {

   530     QVector<FORMATETC> formatics;

   531     if (mimeType.startsWith(QLatin1String("text/plain")) && mimeData->hasText()) {

   532         formatics += setCf(CF_UNICODETEXT);

   533         formatics += setCf(CF_TEXT);

   534     }

   535     return formatics;

   536 }

   537 

   538 QVariant QWindowsMimeText::convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QVariant::Type preferredType) const

   539 {

   540     QVariant ret;

   541 

   542     if (canConvertToMime(mime, pDataObj)) {

   543         QString str;

   544         QByteArray data = getData(CF_UNICODETEXT, pDataObj);

   545         if (!data.isEmpty()) {

   546             str = QString::fromWCharArray((const wchar_t *)data.data());

   547             str.replace(QLatin1String("\r\n"), QLatin1String("\n"));

   548         } else {

   549             data = getData(CF_TEXT, pDataObj);

   550             if (!data.isEmpty()) {

   551                 const char* d = data.data();

   552                 const int s = qstrlen(d);

   553                 QByteArray r(data.size()+1, '\0');

   554                 char* o = r.data();

   555                 int j=0;

   556                 for (int i=0; i<s; i++) {

   557                     char c = d[i];

   558                     if (c!='\r')

   559                         o[j++]=c;

   560                 }

   561                 o[j]=0;

   562                 str = QString::fromLocal8Bit(r);

   563             }

   564         }

   565         if (preferredType == QVariant::String)

   566             ret = str;

   567         else

   568             ret = str.toUtf8();

   569     }

   570 

   571     return ret;

   572 }

   573 

   574 class QWindowsMimeURI : public QWindowsMime

   575 {

   576 public:

   577     QWindowsMimeURI();

   578     bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const;

   579     QVariant convertToMime(const QString &mime, LPDATAOBJECT pDataObj, QVariant::Type preferredType) const;

   580     QString mimeForFormat(const FORMATETC &formatetc) const;

   581     bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const;

   582     bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const;

   583     QVector<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const;

   584 private:

   585     int CF_INETURL_W; // wide char version

   586     int CF_INETURL;

   587 };

   588 

   589 QWindowsMimeURI::QWindowsMimeURI()

   590 {

   591     CF_INETURL_W = QWindowsMime::registerMimeType(QLatin1String("UniformResourceLocatorW"));

   592     CF_INETURL = QWindowsMime::registerMimeType(QLatin1String("UniformResourceLocator"));

   593 }

   594 

   595 bool QWindowsMimeURI::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const

   596 {

   597     if (getCf(formatetc) == CF_HDROP) {

   598         QList<QUrl> urls = mimeData->urls();

   599         for (int i=0; i<urls.size(); i++) {

   600             if (!urls.at(i).toLocalFile().isEmpty())

   601                 return true;

   602         }

   603     }

   604     return (getCf(formatetc) == CF_INETURL_W || getCf(formatetc) == CF_INETURL) && mimeData->hasFormat(QLatin1String("text/uri-list"));

   605 }

   606 

   607 bool QWindowsMimeURI::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM *pmedium) const

   608 {

   609     if (canConvertFromMime(formatetc, mimeData)) {

   610         if (getCf(formatetc) == CF_HDROP) {

   611             QList<QUrl> urls = mimeData->urls();

   612             QStringList fileNames;

   613             int size = sizeof(DROPFILES)+2;

   614             for (int i=0; i<urls.size(); i++) {

   615                 QString fn = QDir::toNativeSeparators(urls.at(i).toLocalFile());

   616                 if (!fn.isEmpty()) {

   617                     size += sizeof(ushort) * (fn.length() + 1);

   618                     fileNames.append(fn);

   619                 }

   620             }

   621 

   622             QByteArray result(size, '\0');

   623             DROPFILES* d = (DROPFILES*)result.data();

   624             d->pFiles = sizeof(DROPFILES);

   625             GetCursorPos(&d->pt); // try

   626             d->fNC = true;

   627             char* files = ((char*)d) + d->pFiles;

   628 

   629             d->fWide = true;

   630             wchar_t* f = (wchar_t*)files;

   631             for (int i=0; i<fileNames.size(); i++) {

   632                 int l = fileNames.at(i).length();

   633                 memcpy(f, fileNames.at(i).utf16(), l * sizeof(ushort));

   634                 f += l;

   635                 *f++ = 0;

   636             }

   637             *f = 0;

   638 

   639             return setData(result, pmedium);

   640         } else if (getCf(formatetc) == CF_INETURL_W) {

   641             QList<QUrl> urls = mimeData->urls();

   642             QByteArray result;

   643             QString url = urls.at(0).toString();

   644             result = QByteArray((const char *)url.utf16(), url.length() * sizeof(ushort));

   645             result.append('\0');

   646             result.append('\0');

   647             return setData(result, pmedium);

   648         } else if (getCf(formatetc) == CF_INETURL) {

   649             QList<QUrl> urls = mimeData->urls();

   650             QByteArray result = urls.at(0).toString().toLocal8Bit();

   651             return setData(result, pmedium);

   652         }

   653     }

   654 

   655     return false;

   656 }

   657 

   658 bool QWindowsMimeURI::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const

   659 {

   660     return mimeType == QLatin1String("text/uri-list")

   661            && (canGetData(CF_HDROP, pDataObj) || canGetData(CF_INETURL_W, pDataObj) || canGetData(CF_INETURL, pDataObj));

   662 }

   663 

   664 QString QWindowsMimeURI::mimeForFormat(const FORMATETC &formatetc) const

   665 {

   666     QString format;

   667     if (getCf(formatetc) == CF_HDROP || getCf(formatetc) == CF_INETURL_W || getCf(formatetc) == CF_INETURL)

   668         format = QLatin1String("text/uri-list");

   669     return format;

   670 }

   671 

   672 QVector<FORMATETC> QWindowsMimeURI::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const

   673 {

   674     QVector<FORMATETC> formatics;

   675     if (mimeType == QLatin1String("text/uri-list")) {

   676         if (canConvertFromMime(setCf(CF_HDROP), mimeData))

   677             formatics += setCf(CF_HDROP);

   678         if (canConvertFromMime(setCf(CF_INETURL_W), mimeData))

   679             formatics += setCf(CF_INETURL_W);

   680         if (canConvertFromMime(setCf(CF_INETURL), mimeData))

   681             formatics += setCf(CF_INETURL);

   682     }

   683     return formatics;

   684 }

   685 

   686 QVariant QWindowsMimeURI::convertToMime(const QString &mimeType, LPDATAOBJECT pDataObj, QVariant::Type preferredType) const

   687 {

   688     if (mimeType == QLatin1String("text/uri-list")) {

   689         if (canGetData(CF_HDROP, pDataObj)) {

   690             QByteArray texturi;

   691             QList<QVariant> urls;

   692 

   693             QByteArray data = getData(CF_HDROP, pDataObj);

   694             if (data.isEmpty())

   695                 return QVariant();

   696 

   697             LPDROPFILES hdrop = (LPDROPFILES)data.data();

   698             if (hdrop->fWide) {

   699                 const wchar_t* filesw = (const wchar_t *)(data.data() + hdrop->pFiles);

   700                 int i = 0;

   701                 while (filesw[i]) {

   702                     QString fileurl = QString::fromWCharArray(filesw + i);

   703                     urls += QUrl::fromLocalFile(fileurl);

   704                     i += fileurl.length()+1;

   705                 }

   706             } else {

   707                 const char* files = (const char *)data.data() + hdrop->pFiles;

   708                 int i=0;

   709                 while (files[i]) {

   710                     urls += QUrl::fromLocalFile(QString::fromLocal8Bit(files+i));

   711                     i += int(strlen(files+i))+1;

   712                 }

   713             }

   714 

   715             if (preferredType == QVariant::Url && urls.size() == 1)

   716                 return urls.at(0);

   717             else if (!urls.isEmpty())

   718                 return urls;

   719         } else if (canGetData(CF_INETURL_W, pDataObj)) {

   720             QByteArray data = getData(CF_INETURL_W, pDataObj);

   721             if (data.isEmpty())

   722                 return QVariant();

   723             return QUrl(QString::fromWCharArray((const wchar_t *)data.constData()));

   724          } else if (canGetData(CF_INETURL, pDataObj)) {

   725             QByteArray data = getData(CF_INETURL, pDataObj);

   726             if (data.isEmpty())

   727                 return QVariant();

   728             return QUrl(QString::fromLocal8Bit(data.constData()));

   729         }

   730     }

   731     return QVariant();

   732 }

   733 

   734 class QWindowsMimeHtml : public QWindowsMime

   735 {

   736 public:

   737     QWindowsMimeHtml();

   738 

   739     // for converting from Qt

   740     bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const;

   741     bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const;

   742     QVector<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const;

   743 

   744     // for converting to Qt

   745     bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const;

   746     QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QVariant::Type preferredType) const;

   747     QString mimeForFormat(const FORMATETC &formatetc) const;

   748 

   749 private:

   750     int CF_HTML;

   751 };

   752 

   753 QWindowsMimeHtml::QWindowsMimeHtml()

   754 {

   755     CF_HTML = QWindowsMime::registerMimeType(QLatin1String("HTML Format"));

   756 }

   757 

   758 QVector<FORMATETC> QWindowsMimeHtml::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const

   759 {

   760     QVector<FORMATETC> formatetcs;

   761     if (mimeType == QLatin1String("text/html") && (!mimeData->html().isEmpty()))

   762         formatetcs += setCf(CF_HTML);

   763     return formatetcs;

   764 }

   765 

   766 QString QWindowsMimeHtml::mimeForFormat(const FORMATETC &formatetc) const

   767 {

   768     if (getCf(formatetc) == CF_HTML)

   769         return QLatin1String("text/html");

   770     return QString();

   771 }

   772 

   773 bool QWindowsMimeHtml::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const

   774 {

   775     return mimeType == QLatin1String("text/html") && canGetData(CF_HTML, pDataObj);

   776 }

   777 

   778 

   779 bool QWindowsMimeHtml::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const

   780 {

   781     return getCf(formatetc) == CF_HTML && (!mimeData->html().isEmpty());

   782 }

   783 

   784 /*

   785 The windows HTML clipboard format is as follows (xxxxxxxxxx is a 10 integer number giving the positions

   786 in bytes). Charset used is mostly utf8, but can be different, ie. we have to look for the <meta> charset tag

   787 

   788   Version: 1.0

   789   StartHTML:xxxxxxxxxx

   790   EndHTML:xxxxxxxxxx

   791   StartFragment:xxxxxxxxxx

   792   EndFragment:xxxxxxxxxx

   793   ...html...

   794 

   795 */

   796 QVariant QWindowsMimeHtml::convertToMime(const QString &mime, IDataObject *pDataObj, QVariant::Type preferredType) const

   797 {

   798     Q_UNUSED(preferredType);

   799     QVariant result;

   800     if (canConvertToMime(mime, pDataObj)) {

   801         QByteArray html = getData(CF_HTML, pDataObj);

   802 #ifdef QMIME_DEBUG

   803         qDebug("QWindowsMimeHtml::convertToMime");

   804         qDebug("raw :");

   805         qDebug(html);

   806 #endif

   807         int start = html.indexOf("StartFragment:");

   808         int end = html.indexOf("EndFragment:");

   809 

   810         if (start != -1) {

   811             int startOffset = start + 14;

   812             int i = startOffset;

   813             while (html.at(i) != '\r' && html.at(i) != '\n')

   814                 ++i;

   815             QByteArray bytecount = html.mid(startOffset, i - startOffset);

   816             start = bytecount.toInt();

   817         }

   818 

   819         if (end != -1) {

   820             int endOffset = end + 12;

   821             int i = endOffset ;

   822             while (html.at(i) != '\r' && html.at(i) != '\n')

   823                 ++i;

   824             QByteArray bytecount = html.mid(endOffset , i - endOffset);

   825             end = bytecount.toInt();

   826         }

   827 

   828         if (end > start && start > 0) {

   829             html = "<!--StartFragment-->" + html.mid(start, end - start);

   830             html += "<!--EndFragment-->";

   831             html.replace('\r', "");

   832             result = QString::fromUtf8(html);

   833         }

   834     }

   835     return result;

   836 }

   837 

   838 bool QWindowsMimeHtml::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const

   839 {

   840     if (canConvertFromMime(formatetc, mimeData)) {

   841         QByteArray data = mimeData->html().toUtf8();

   842         QByteArray result =

   843             "Version:1.0\r\n"                    // 0-12

   844             "StartHTML:0000000105\r\n"            // 13-35

   845             "EndHTML:0000000000\r\n"            // 36-55

   846             "StartFragment:0000000000\r\n"            // 58-86

   847             "EndFragment:0000000000\r\n\r\n";   // 87-105

   848 

   849         if (data.indexOf("<!--StartFragment-->") == -1)

   850             result += "<!--StartFragment-->";

   851         result += data;

   852         if (data.indexOf("<!--EndFragment-->") == -1)

   853             result += "<!--EndFragment-->";

   854 

   855         // set the correct number for EndHTML

   856         QByteArray pos = QString::number(result.size()).toLatin1();

   857         memcpy((char *)(result.data() + 53 - pos.length()), pos.constData(), pos.length());

   858 

   859         // set correct numbers for StartFragment and EndFragment

   860         pos = QString::number(result.indexOf("<!--StartFragment-->") + 20).toLatin1();

   861         memcpy((char *)(result.data() + 79 - pos.length()), pos.constData(), pos.length());

   862         pos = QString::number(result.indexOf("<!--EndFragment-->")).toLatin1();

   863         memcpy((char *)(result.data() + 103 - pos.length()), pos.constData(), pos.length());

   864 

   865         return setData(result, pmedium);

   866     }

   867     return false;

   868 }

   869 

   870 

   871 #ifndef QT_NO_IMAGEFORMAT_BMP

   872 class QWindowsMimeImage : public QWindowsMime

   873 {

   874 public:

   875     QWindowsMimeImage();

   876     // for converting from Qt

   877     bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const;

   878     bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const;

   879     QVector<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const;

   880 

   881     // for converting to Qt

   882     bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const;

   883     QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QVariant::Type preferredType) const;

   884     QString mimeForFormat(const FORMATETC &formatetc) const;

   885 private:

   886     bool hasOriginalDIBV5(IDataObject *pDataObj) const;

   887     UINT CF_PNG;

   888 };

   889 

   890 QWindowsMimeImage::QWindowsMimeImage()

   891 {

   892     CF_PNG = RegisterClipboardFormat(L"PNG");

   893 }

   894 

   895 QVector<FORMATETC> QWindowsMimeImage::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const

   896 {

   897     QVector<FORMATETC> formatetcs;

   898     if (mimeData->hasImage() && mimeType == QLatin1String("application/x-qt-image")) {

   899         //add DIBV5 if image has alpha channel

   900         QImage image = qvariant_cast<QImage>(mimeData->imageData());

   901         if (!image.isNull() && image.hasAlphaChannel())

   902             formatetcs += setCf(CF_DIBV5);

   903         formatetcs += setCf(CF_DIB);

   904     }

   905     return formatetcs;

   906 }

   907 

   908 QString QWindowsMimeImage::mimeForFormat(const FORMATETC &formatetc) const

   909 {

   910     int cf = getCf(formatetc);

   911     if (cf == CF_DIB || cf == CF_DIBV5 || cf == int(CF_PNG))

   912        return QLatin1String("application/x-qt-image");

   913     return QString();

   914 }

   915 

   916 bool QWindowsMimeImage::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const

   917 {

   918     if ((mimeType == QLatin1String("application/x-qt-image")) &&

   919         (canGetData(CF_DIB, pDataObj) || canGetData(CF_PNG, pDataObj)))

   920         return true;

   921     return false;

   922 }

   923 

   924 bool QWindowsMimeImage::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const

   925 {

   926     int cf = getCf(formatetc);

   927     if (mimeData->hasImage()) {

   928         if (cf == CF_DIB)

   929             return true;

   930         else if (cf == CF_DIBV5) {

   931             //support DIBV5 conversion only if the image has alpha channel

   932             QImage image = qvariant_cast<QImage>(mimeData->imageData());

   933             if (!image.isNull() && image.hasAlphaChannel())

   934                 return true;

   935         }

   936     }

   937     return false;

   938 }

   939 

   940 bool QWindowsMimeImage::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const

   941 {

   942     int cf = getCf(formatetc);

   943     if ((cf == CF_DIB || cf == CF_DIBV5) && mimeData->hasImage()) {

   944         QImage img = qvariant_cast<QImage>(mimeData->imageData());

   945         if (img.isNull())

   946             return false;

   947         QByteArray ba;

   948         QDataStream s(&ba, QIODevice::WriteOnly);

   949         s.setByteOrder(QDataStream::LittleEndian);// Intel byte order ####

   950         if (cf == CF_DIB) {

   951             if (qt_write_dib(s, img))

   952                 return setData(ba, pmedium);

   953         } else {

   954             if (qt_write_dibv5(s, img))

   955                 return setData(ba, pmedium);

   956         }

   957     }

   958     return false;

   959 }

   960 

   961 bool QWindowsMimeImage::hasOriginalDIBV5(IDataObject *pDataObj) const

   962 {

   963     bool isSynthesized = true;

   964     IEnumFORMATETC *pEnum =NULL;

   965     HRESULT res = pDataObj->EnumFormatEtc(1, &pEnum);

   966     if (res == S_OK && pEnum) {

   967         FORMATETC fc;

   968         while ((res = pEnum->Next(1, &fc, 0)) == S_OK) {

   969             if (fc.ptd)

   970                 CoTaskMemFree(fc.ptd);

   971             if (fc.cfFormat == CF_DIB)

   972                 break;

   973             else if (fc.cfFormat == CF_DIBV5) {

   974                 isSynthesized  = false;

   975                 break;

   976             }

   977         }

   978         pEnum->Release();

   979     }

   980     return !isSynthesized;

   981 }

   982 

   983 QVariant QWindowsMimeImage::convertToMime(const QString &mimeType, IDataObject *pDataObj, QVariant::Type preferredType) const

   984 {

   985     Q_UNUSED(preferredType);

   986     QVariant result;

   987     if (mimeType != QLatin1String("application/x-qt-image"))

   988         return result;

   989     //Try to convert from a format which has more data

   990     //DIBV5, use only if its is not synthesized

   991     if (canGetData(CF_DIBV5, pDataObj) && hasOriginalDIBV5(pDataObj)) {

   992         QImage img;

   993         QByteArray data = getData(CF_DIBV5, pDataObj);

   994         QDataStream s(&data, QIODevice::ReadOnly);

   995         s.setByteOrder(QDataStream::LittleEndian);

   996         if (qt_read_dibv5(s, img)) { // #### supports only 32bit DIBV5

   997             return img;

   998         }

   999     }

  1000     //PNG, MS Office place this (undocumented)

  1001     if (canGetData(CF_PNG, pDataObj)) {

  1002         QImage img;

  1003         QByteArray data = getData(CF_PNG, pDataObj);

  1004         if (img.loadFromData(data, "PNG")) {

  1005             return img;

  1006         }

  1007     }

  1008     //Fallback to DIB

  1009     if (canGetData(CF_DIB, pDataObj)) {

  1010         QImage img;

  1011         QByteArray data = getData(CF_DIB, pDataObj);

  1012         QDataStream s(&data, QIODevice::ReadOnly);

  1013         s.setByteOrder(QDataStream::LittleEndian);// Intel byte order ####

  1014         if (qt_read_dib(s, img)) { // ##### encaps "-14"

  1015             return img;

  1016         }

  1017     }

  1018     // Failed

  1019     return result;

  1020 }

  1021 #endif

  1022 

  1023 class QBuiltInMimes : public QWindowsMime

  1024 {

  1025 public:

  1026     QBuiltInMimes();

  1027 

  1028     // for converting from Qt

  1029     bool canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const;

  1030     bool convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const;

  1031     QVector<FORMATETC> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const;

  1032 

  1033     // for converting to Qt

  1034     bool canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const;

  1035     QVariant convertToMime(const QString &mime, IDataObject *pDataObj, QVariant::Type preferredType) const;

  1036     QString mimeForFormat(const FORMATETC &formatetc) const;

  1037 

  1038 private:

  1039     QMap<int, QString> outFormats;

  1040     QMap<int, QString> inFormats;

  1041 };

  1042 

  1043 QBuiltInMimes::QBuiltInMimes()

  1044 : QWindowsMime()

  1045 {

  1046     outFormats.insert(QWindowsMime::registerMimeType(QLatin1String("application/x-color")), QLatin1String("application/x-color"));

  1047     inFormats.insert(QWindowsMime::registerMimeType(QLatin1String("application/x-color")), QLatin1String("application/x-color"));

  1048 }

  1049 

  1050 bool QBuiltInMimes::canConvertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData) const

  1051 {

  1052     // really check

  1053     return formatetc.tymed & TYMED_HGLOBAL

  1054         && outFormats.contains(formatetc.cfFormat)

  1055         && mimeData->formats().contains(outFormats.value(formatetc.cfFormat));

  1056 }

  1057 

  1058 bool QBuiltInMimes::convertFromMime(const FORMATETC &formatetc, const QMimeData *mimeData, STGMEDIUM * pmedium) const

  1059 {

  1060     if (canConvertFromMime(formatetc, mimeData)) {

  1061         QByteArray data;

  1062         if (outFormats.value(getCf(formatetc)) == QLatin1String("text/html")) {

  1063             // text/html is in wide chars on windows (compatible with mozillia)

  1064             QString html = mimeData->html();

  1065             // same code as in the text converter up above

  1066             const QChar *u = html.unicode();

  1067             QString res;

  1068             const int s = html.length();

  1069             int maxsize = s + s/40 + 3;

  1070             res.resize(maxsize);

  1071             int ri = 0;

  1072             bool cr = false;

  1073             for (int i=0; i < s; ++i) {

  1074                 if (*u == QLatin1Char('\r'))

  1075                     cr = true;

  1076                 else {

  1077                     if (*u == QLatin1Char('\n') && !cr)

  1078                         res[ri++] = QLatin1Char('\r');

  1079                     cr = false;

  1080                 }

  1081                 res[ri++] = *u;

  1082                 if (ri+3 >= maxsize) {

  1083                     maxsize += maxsize/4;

  1084                     res.resize(maxsize);

  1085                 }

  1086                 ++u;

  1087             }

  1088             res.truncate(ri);

  1089             const int byteLength = res.length() * sizeof(ushort);

  1090             QByteArray r(byteLength + 2, '\0');

  1091             memcpy(r.data(), res.unicode(), byteLength);

  1092             r[byteLength] = 0;

  1093             r[byteLength+1] = 0;

  1094             data = r;

  1095         } else {

  1096 #ifndef QT_NO_DRAGANDDROP

  1097             data = QInternalMimeData::renderDataHelper(outFormats.value(getCf(formatetc)), mimeData);

  1098 #endif //QT_NO_DRAGANDDROP

  1099         }

  1100         return setData(data, pmedium);

  1101     }

  1102     return false;

  1103 }

  1104 

  1105 QVector<FORMATETC> QBuiltInMimes::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const

  1106 {

  1107     QVector<FORMATETC> formatetcs;

  1108     if (!outFormats.keys(mimeType).isEmpty() && mimeData->formats().contains(mimeType))

  1109         formatetcs += setCf(outFormats.key(mimeType));

  1110     return formatetcs;

  1111 }

  1112 

  1113 bool QBuiltInMimes::canConvertToMime(const QString &mimeType, IDataObject *pDataObj) const

  1114 {

  1115     return (!inFormats.keys(mimeType).isEmpty())

  1116         && canGetData(inFormats.key(mimeType), pDataObj);

  1117 }

  1118 

  1119 QVariant QBuiltInMimes::convertToMime(const QString &mimeType, IDataObject *pDataObj, QVariant::Type preferredType) const

  1120 {

  1121     QVariant val;

  1122     if (canConvertToMime(mimeType, pDataObj)) {

  1123         QByteArray data = getData(inFormats.key(mimeType), pDataObj);

  1124         if (!data.isEmpty()) {

  1125 #ifdef QMIME_DEBUG

  1126             qDebug("QBuiltInMimes::convertToMime()");

  1127 #endif

  1128             if (mimeType == QLatin1String("text/html") && preferredType == QVariant::String) {

  1129                 // text/html is in wide chars on windows (compatible with Mozilla)

  1130                 val = QString::fromWCharArray((const wchar_t *)data.data());

  1131             } else {

  1132                 val = data; // it should be enough to return the data and let QMimeData do the rest.

  1133             }

  1134         }