/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qmime.h"

#include "qimagereader.h"

#include "qimagewriter.h"

#include "qdatastream.h"

#include "qbuffer.h"

#include "qt_windows.h"

#include "qapplication_p.h"

#include "qtextcodec.h"

#include "qregexp.h"

#include "qalgorithms.h"

#include "qmap.h"

#include "qdnd_p.h"

#include <shlobj.h>

#include "qurl.h"

#include "qvariant.h"

#include "qtextdocument.h"

#include "qdir.h"

#if defined(Q_OS_WINCE)

#include "qguifunctions_wince.h"

#endif

QT_BEGIN_NAMESPACE

#ifndef QT_NO_IMAGEFORMAT_BMP

#ifndef CF_DIBV5

#define CF_DIBV5 17

#endif

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

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

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

 * on conformant C++ compilers. */

#define BMP_LCS_sRGB  0x73524742

#define BMP_LCS_GM_IMAGES  0x00000004L

struct _CIEXYZ {

    long ciexyzX, ciexyzY, ciexyzZ;

};

struct _CIEXYZTRIPLE {

    _CIEXYZ  ciexyzRed, ciexyzGreen, ciexyzBlue;

};

struct BMP_BITMAPV5HEADER {

    DWORD  bV5Size;

    LONG   bV5Width;

    LONG   bV5Height;

    WORD   bV5Planes;

    WORD   bV5BitCount;

    DWORD  bV5Compression;

    DWORD  bV5SizeImage;

    LONG   bV5XPelsPerMeter;

    LONG   bV5YPelsPerMeter;

    DWORD  bV5ClrUsed;

    DWORD  bV5ClrImportant;

    DWORD  bV5RedMask;

    DWORD  bV5GreenMask;

    DWORD  bV5BlueMask;

    DWORD  bV5AlphaMask;

    DWORD  bV5CSType;

    _CIEXYZTRIPLE bV5Endpoints;

    DWORD  bV5GammaRed;

    DWORD  bV5GammaGreen;

    DWORD  bV5GammaBlue;

    DWORD  bV5Intent;

    DWORD  bV5ProfileData;

    DWORD  bV5ProfileSize;

    DWORD  bV5Reserved;

};

static const int BMP_BITFIELDS = 3;

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

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

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

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

#endif

//#define QMIME_DEBUG

// helpers for using global memory

static int getCf(const FORMATETC &formatetc)

{

    return formatetc.cfFormat;

}

static FORMATETC setCf(int cf)

{

    FORMATETC formatetc;

    formatetc.cfFormat = cf;

    formatetc.dwAspect = DVASPECT_CONTENT;

    formatetc.lindex = -1;

    formatetc.ptd = NULL;

    formatetc.tymed = TYMED_HGLOBAL;

    return formatetc;

}

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

{

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

    if (!hData)

        return false;

    void *out = GlobalLock(hData);

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

    GlobalUnlock(hData);

    pmedium->tymed = TYMED_HGLOBAL;

    pmedium->hGlobal = hData;

    pmedium->pUnkForRelease = 0;

    return true;

}

static QByteArray getData(int cf, IDataObject *pDataObj)

{

    QByteArray data;

    FORMATETC formatetc = setCf(cf);

    STGMEDIUM s;

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

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

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

        data.detach();

        GlobalUnlock(s.hGlobal);

        ReleaseStgMedium(&s);

    } else  {

        //Try reading IStream data

        formatetc.tymed = TYMED_ISTREAM;

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

            char szBuffer[4096];

            ULONG actualRead = 0;

            LARGE_INTEGER pos = {{0, 0}};

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

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

            while(SUCCEEDED(hr)){

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

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

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

                }

                if (actualRead != sizeof(szBuffer))

                    break;

            }

            data.detach();

            ReleaseStgMedium(&s);

        }

    }

    return data;

}

static bool canGetData(int cf, IDataObject * pDataObj)

{

    FORMATETC formatetc = setCf(cf);

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

        formatetc.tymed = TYMED_ISTREAM;

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

    }

    return true;

}

class QWindowsMimeList

{

public:

    QWindowsMimeList();

    ~QWindowsMimeList();

    void addWindowsMime(QWindowsMime * mime);

    void removeWindowsMime(QWindowsMime * mime);

    QList<QWindowsMime*> windowsMimes();

private:

    void init();

    bool initialized;

    QList<QWindowsMime*> mimes;

};

Q_GLOBAL_STATIC(QWindowsMimeList, theMimeList);

/*!

    \class QWindowsMime

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

    \ingroup draganddrop

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

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

    although some applications use MIME types to describe clipboard

    formats, others use arbitrary non-standardized naming conventions,

    or unnamed built-in formats of Windows.

    By instantiating subclasses of QWindowsMime that provide conversions

    between Windows Clipboard and MIME formats, you can convert

    proprietary clipboard formats to MIME formats.

    Qt has predefined support for the following Windows Clipboard formats:

    \table

    \header \o Windows Format \o Equivalent MIME type

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

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

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

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

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

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

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

    \endtable

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

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

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

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

    for more information on choosing and definition MIME types.

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

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

*/

/*!

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

list of available converters.

*/

QWindowsMime::QWindowsMime()

{

    theMimeList()->addWindowsMime(this);

}

/*!

Destroys a conversion object, removing it from the global

list of available converters.

*/

QWindowsMime::~QWindowsMime()

{

    theMimeList()->removeWindowsMime(this);

}

/*!

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

    identifying the format on Windows.

*/

int QWindowsMime::registerMimeType(const QString &mime)

{

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

    if (!f)

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

    return f;

}

/*!

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

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

  the format specified in \a formatetc.

  All subclasses must reimplement this pure virtual function.

*/

/*!

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

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

  the available formats in \a pDataObj.

  All subclasses must reimplement this pure virtual function.

*/

/*!

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

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

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

  \a formatetc.

  All subclasses must reimplement this pure virtual function.

*/

/*!

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

  Returns a QVector of FORMATETC structures representing the different windows clipboard

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

  All subclasses must reimplement this pure virtual function.

*/

/*!

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

                                             QVariant::Type preferredType) const

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

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

    All subclasses must reimplement this pure virtual function.

*/

/*!

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

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

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

  Return true if the conversion was successful.

  All subclasses must reimplement this pure virtual function.

*/

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

{

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

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

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

            return mimes.at(i);

    }

    return 0;

}

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

{

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

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

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

            return mimes.at(i);

    }

    return 0;

}

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

{

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

    QVector<FORMATETC> formatics;

    formatics.reserve(20);

#ifndef QT_NO_DRAGANDDROP

    QStringList formats = QInternalMimeData::formatsHelper(mimeData);

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

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

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

    }

#else

    Q_UNUSED(mimeData);

#endif //QT_NO_DRAGANDDROP

    return formatics;

}

QStringList QWindowsMime::allMimesForFormats(IDataObject *pDataObj)

{

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

    QStringList formats;

    LPENUMFORMATETC FAR fmtenum;

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

    if (hr == NOERROR) {

        FORMATETC fmtetc;

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

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

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

            wchar_t buf[256] = {0};

            GetClipboardFormatName(fmtetc.cfFormat, buf, 255);

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

#endif

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

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

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

                    formats += format;

                }

            }

            // as documented in MSDN to avoid possible memleak

            if (fmtetc.ptd)

                CoTaskMemFree(fmtetc.ptd);

        }

        fmtenum->Release();

    }

    return formats;

}

class QWindowsMimeText : public QWindowsMime

{

public:

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

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

    QString mimeForFormat(const FORMATETC &formatetc) const;

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

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

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

};

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

{

    int cf = getCf(formatetc);

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

}

/*

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

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

Windows really needs CRLF, so we ensure it here.

*/

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

{

    if (canConvertFromMime(formatetc, mimeData)) {

        QByteArray data;

        int cf = getCf(formatetc);

        if (cf == CF_TEXT) {

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

            // Anticipate required space for CRLFs at 1/40

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

            QByteArray r(maxsize, '\0');

            char* o = r.data();

            const char* d = data.data();

            const int s = data.size();

            bool cr=false;

            int j=0;

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

                char c = d[i];

                if (c=='\r')

                    cr=true;

                else {

                    if (c=='\n') {

                        if (!cr)

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

                    }

                    cr=false;

                }

                o[j++]=c;

                if (j+3 >= maxsize) {

                    maxsize += maxsize/4;

                    r.resize(maxsize);

                    o = r.data();

                }

            }

            o[j]=0;

            return setData(r, pmedium);

        } else if (cf == CF_UNICODETEXT) {

            QString str = mimeData->text();

            const QChar *u = str.unicode();

            QString res;

            const int s = str.length();

            int maxsize = s + s/40 + 3;

            res.resize(maxsize);

            int ri = 0;

            bool cr = false;

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

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

                    cr = true;

                else {

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

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

                    cr = false;

                }

                res[ri++] = *u;

                if (ri+3 >= maxsize) {

                    maxsize += maxsize/4;

                    res.resize(maxsize);

                }

                ++u;

            }

            res.truncate(ri);

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

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

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

            r[byteLength] = 0;

            r[byteLength+1] = 0;

            return setData(r, pmedium);

        }

    }

    return false;

}

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

{

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

           && (canGetData(CF_UNICODETEXT, pDataObj)

           || canGetData(CF_TEXT, pDataObj));

}

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

{

    int cf = getCf(formatetc);

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

        return QLatin1String("text/plain");

    return QString();

}

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