/******************************************************************************** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.**** This file is part of the QtCore module of the Qt Toolkit.**** This file may be used under the terms of the GNU General Public** License version 2.0 as published by the Free Software Foundation** and appearing in the file LICENSE.GPL included in the packaging of** this file.  Please review the following information to ensure GNU** General Public Licensing requirements will be met:** http://www.trolltech.com/products/qt/opensource.html**** If you are unsure which license is appropriate for your use, please** review the following information:** http://www.trolltech.com/products/qt/licensing.html or contact the** sales department at sales@trolltech.com.**** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.******************************************************************************/#include "qmimedata.h"#include "private/qobject_p.h"#include "qurl.h"#include "qstringlist.h"#include "qtextcodec.h"struct QMimeDataStruct{    QString format;    QVariant data;};class QMimeDataPrivate : public QObjectPrivate{    Q_DECLARE_PUBLIC(QMimeData)public:    void setData(const QString &format, const QVariant &data);    QVariant getData(const QString &format) const;    QVariant retrieveTypedData(const QString &format, QVariant::Type type) const;    QList<QMimeDataStruct> dataList;};void QMimeDataPrivate::setData(const QString &format, const QVariant &data){    // remove it first if the format is already here.    for (int i=0; i<dataList.size(); i++) {        if (dataList.at(i).format == format) {            dataList.removeAt(i);            break;        }    }    QMimeDataStruct mimeData;    mimeData.format = format;    mimeData.data = data;    dataList += mimeData;}QVariant QMimeDataPrivate::getData(const QString &format) const{    QVariant data;    for (int i=0; i<dataList.size(); i++) {        if (dataList.at(i).format == format) {            data = dataList.at(i).data;            break;        }    }    return data;}QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Type type) const{    Q_Q(const QMimeData);    QVariant data = q->retrieveData(format, type);    if (data.type() == type || data.type() == QVariant::Invalid)        return data;    // provide more conversion possiblities than just what QVariant provides    // URLs can be lists as well...    if (type == QVariant::Url && data.type() == QVariant::List        || type == QVariant::List && data.type() == QVariant::Url)        return data;    // images and pixmaps are interchangeable    if (type == QVariant::Pixmap && data.type() == QVariant::Image        || type == QVariant::Image && data.type() == QVariant::Pixmap)        return data;    if (data.type() == QVariant::ByteArray) {        // see if we can convert to the requested type        switch(type) {#ifndef QT_NO_TEXTCODEC        case QVariant::String: {            const QByteArray ba = data.toByteArray();            QTextCodec *codec = QTextCodec::codecForName("utf-8");            if (format == QLatin1String("text/html"))                codec = QTextCodec::codecForHtml(ba);            return codec->toUnicode(ba);        }#endif // QT_NO_TEXTCODEC        case QVariant::Color: {            QVariant newData = data;            newData.convert(QVariant::Color);            return newData;        }        case QVariant::List: {            if (format != QLatin1String("text/uri-list"))                break;            // fall through        }        case QVariant::Url: {            QList<QVariant> list;            QList<QByteArray> urls = data.toByteArray().split('\n');            for (int i = 0; i < urls.size(); ++i) {                QByteArray ba = urls.at(i).trimmed();                list.append(QUrl::fromEncoded(ba));            }            return list;        }        default:            break;        }    } else if (type == QVariant::ByteArray) {        // try to convert to bytearray        switch(data.type()) {        case QVariant::ByteArray:        case QVariant::Color:            return data.toByteArray();            break;        case QVariant::String:            return data.toString().toUtf8();            break;        case QVariant::Url:            return data.toUrl().toEncoded();            break;        case QVariant::List: {            // has to be list of URLs            QByteArray result;            QList<QVariant> list = data.toList();            for (int i = 0; i < list.size(); ++i) {                if (list.at(i).type() == QVariant::Url) {                    result += list.at(i).toUrl().toEncoded();                    result += "\r\n";                }            }            if (!result.isEmpty())                return result;            break;        }        default:            break;        }    }    return data;}/*!    \class QMimeData    \brief The QMimeData class provides a container for data that records information    about its MIME type.    QMimeData is used to describe information that can be stored in    the \l{QClipboard}{clipboard}, and transferred via the \l{drag    and drop} mechanism. QMimeData objects associate the data that    they hold with the corresponding MIME types to ensure that    information can be safely transferred between applications, and    copied around within the same application.    QMimeData objects are usually created using \c new and supplied    to QDrag or QClipboard objects. This is to enable Qt to manage    the memory that they use.    A single QMimeData object can store the same data using several    different formats at the same time. The formats() function    returns a list of the available formats in order of preference.    The data() function returns the raw data associated with a MIME    type, and setData() allows you to set the data for a MIME type.    For the most common MIME types, QMimeData provides convenience    functions to access the data:    \table    \header \o Tester       \o Getter       \o Setter           \o MIME Types    \row    \o hasText()    \o text()       \o setText()        \o \c text/plain    \row    \o hasHtml()    \o html()       \o setHtml()        \o \c text/html    \row    \o hasUrls()    \o urls()       \o setUrls()        \o \c text/uri-list    \row    \o hasImage()   \o imageData()  \o setImageData()   \o \c image/ *    \row    \o hasColor()   \o colorData()  \o setColorData()   \o \c application/x-color    \endtable    For example, if your write a widget that accepts URL drags, you    would end up writing code like this:    \code        void MyWidget::dragEnterEvent(QDragEnterEvent *event)        {            if (event->mimeData()->hasUrl())                event->acceptProposedEvent();        }        void MyWidget::dropEvent(QDropEvent *event)        {            if (event->mimeData()->hasUrl()) {                QUrl url = event->mimeData()->url();                ...            }        }    \endcode    There are three appraches for storing custom data in a QMimeData    object:    \list 1    \o  Custom data can be stored directly in a QMimeData object as a        QByteArray using setData(). For example:        \code            QByteArray csvData = ...;            QMimeData *mimeData = new QMimeData;            mimeData->setData("text/csv", csvData);        \endcode    \o  We can subclass QMimeData and reimplement hasFormat(),        formats(), and retrieveData().    \o  If the drag and drop operation occurs withing a single        application, we can subclass QMimeData and add extra data in        it, and use a qobject_cast() in the receiver's drop event        handler. For example:        \code        void MyWidget::dropEvent(QDropEvent *event)        {            const MyMimeData *myData =                    qobject_cast<const MyMimeData *>(event->mimeData());            if (myData) {                // access myData's data directly (not through QMimeData's API)            }        }        \endcode    \endlist    \sa QClipboard, QDragEnterEvent, QDragMoveEvent, QDropEvent, QDrag,        {Drag and Drop}*//*!    Constructs a new MIME data object with no data in it.*/QMimeData::QMimeData()    : QObject(*new QMimeDataPrivate, 0){}/*!    Destroys the MIME data object.*/QMimeData::~QMimeData(){}/*!    Returns a list of URLs contained within the MIME data object.    URLs correspond to the MIME type \c text/uri-list.    \sa hasUrls(), data()*/QList<QUrl> QMimeData::urls() const{    Q_D(const QMimeData);    QVariant data = d->retrieveTypedData(QLatin1String("text/uri-list"), QVariant::List);    QList<QUrl> urls;    if (data.type() == QVariant::Url)        urls.append(data.toUrl());    else if (data.type() == QVariant::List) {        QList<QVariant> list = data.toList();        for (int i = 0; i < list.size(); ++i) {            if (list.at(i).type() == QVariant::Url)                urls.append(list.at(i).toUrl());        }    }    return urls;}/*!