Changeset 465


Ignore:
Timestamp:
Jan 22, 2010, 12:24:57 PM (16 years ago)
Author:
Dmitry A. Kuminov
Message:

gui: DnD: QPMAnyMime: Added fallback support for any mime type not supported by dedicated converters.

Location:
trunk/src/gui/kernel
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gui/kernel/qdnd_pm.cpp

    r464 r465  
    10241024    static ULONG itemID = 0;
    10251025
    1026     const char *type = 0;
    1027     const char *ext = 0;
     1026    QString type;
     1027    QString ext;
    10281028    firstWorker->defaultFileType(type, ext);
    10291029
    … …  
    10431043            name = QString(QLatin1String("%1 %2")).arg(targetName).arg(i + 1);
    10441044
    1045         if (ext) {
    1046             name += QLatin1Char('.');
    1047             name += QFile::decodeName(QByteArray(ext));
    1048         }
     1045        if (!ext.isEmpty())
     1046            name += QString(QLatin1String(".%1")).arg(ext);
    10491047
    10501048        DEBUG(() << "QPMCoopDragWorker: item" << i << ": type" << type
    … …  
    10621060        item->hwndItem = hwnd();
    10631061        item->ulItemID = itemID ++;
    1064         item->hstrType = DrgAddStrHandle(type ? type : DRT_UNKNOWN);
     1062        item->hstrType = DrgAddStrHandle(!type.isEmpty() ?
     1063                                         QFile::encodeName(type) : DRT_UNKNOWN);
    10651064        item->hstrRMF = DrgAddStrHandle(allFormats);
    10661065        item->hstrContainerName = 0;

  • trunk/src/gui/kernel/qmime.h

    r448 r465  
    154154        virtual bool prepare(const char *drm, const char *drf, DRAGITEM *item,
    155155                             ULONG itemIndex) { return false; }
    156         virtual void defaultFileType(const char *&type, const char *&ext) {};
     156        virtual void defaultFileType(QString &type, QString &ext) {};
    157157
    158158    private:
    … …  
    169169        virtual ~DefaultDragWorker();
    170170
    171         // DragpWorker interface
     171        // DragWorker interface
    172172        bool cleanup(bool isCancelled);
    173173        bool isExclusive() const;
    … …  
    177177        bool prepare(const char *drm, const char *drf, DRAGITEM *item,
    178178                     ULONG itemIndex);
    179         void defaultFileType(const char *&type, const char *&ext);
     179        void defaultFileType(QString &type, QString &ext);
    180180
    181181        // QPMObjectWindow interface
    … …  
    188188            virtual bool provide(const char *drf, const QByteArray &allData,
    189189                                 ULONG itemIndex, QByteArray &itemData) = 0;
    190             virtual void fileType(const char *drf, const char *&type,
    191                                   const char *&ext) {};
     190            virtual void fileType(const char *drf, QString &type, QString &ext) {};
    192191        };
    193192
    194         bool addProvider(const char *drf, Provider *provider,
     193        bool addProvider(const QByteArray &drf, Provider *provider,
    195194                         ULONG itemCount = 1);
    196195
    … …  
    246245        {
    247246        public:
    248             virtual const char *drf(const QString &mimeType) const = 0;
     247            virtual QByteArray drf(const QString &mimeType) const = 0;
    249248            virtual bool provide(const QString &mimeType, ULONG itemIndex,
    250249                                 const QByteArray &itemData,
    … …  
    255254        bool addExclusiveProvider(const QString &mimeType, Provider *provider);
    256255
    257         static bool canRender(DRAGITEM *item, const char *drf );
     256        static bool canRender(DRAGITEM *item, const char *drf);
    258257        static bool getSupportedRMFs(DRAGITEM *item, QList<QByteArrayList> &list);
    259258

  • trunk/src/gui/kernel/qmime_pm.cpp

    r461 r465  
    213213}
    214214
    215 // -----------------------------------------------------------------------------
     215//------------------------------------------------------------------------------
    216216
    217217struct QPMMime::DefaultDragWorker::Data
    … …  
    248248    {
    249249        DrfProvider() : prov(0) {}
    250         DrfProvider(const char *d, Provider *p) : drf(d), prov(p) {}
     250        DrfProvider(const QByteArray &d, Provider *p) : drf(d), prov(p) {}
    251251        QByteArray drf;
    252252        Provider *prov;
    … …  
    421421}
    422422
    423 void QPMMime::DefaultDragWorker::defaultFileType(const char *&type,
    424                                                  const char *&ext)
     423void QPMMime::DefaultDragWorker::defaultFileType(QString &type,
     424                                                 QString &ext)
    425425{
    426426    Q_ASSERT(d->providers.count());
    … …  
    580580                        req->sharedMem = ptr;
    581581                        DEBUG(() << "DefaultDragWorker: Created shared memory "
    582                                     "object" << ptr);
     582                                    "object" << (void *)ptr);
    583583#ifndef QT_NO_DEBUG
    584584                    } else {
    … …  
    665665}
    666666
    667 bool QPMMime::DefaultDragWorker::addProvider(const char *drf, Provider *provider,
     667bool QPMMime::DefaultDragWorker::addProvider(const QByteArray &drf, Provider *provider,
    668668                                             ULONG itemCnt /* = 1 */)
    669669{
    … …  
    671671    d->cleanupRequests();
    672672
    673     Q_ASSERT(drf && provider && itemCnt >= 1);
    674     if (drf && provider && itemCnt >= 1) {
     673    Q_ASSERT(!drf.isEmpty() && provider && itemCnt >= 1);
     674    if (!drf.isEmpty() && provider && itemCnt >= 1) {
    675675        if (d->providers.count() == 0) {
    676676            // first provider
    … …  
    828828        return ret;
    829829
    830     const char *drf = provider->drf(mimeType);
    831     Q_ASSERT(drf);
    832     if (!drf)
     830    QByteArray drf = provider->drf(mimeType);
     831    Q_ASSERT(!drf.isEmpty());
     832    if (drf.isEmpty())
    833833        return ret;
    834834
    … …  
    849849
    850850    HSTR rmfOS2File =
    851         DrgAddStrHandle(QString().sprintf("<DRM_OS2FILE,%s>", drf).toLocal8Bit());
     851        DrgAddStrHandle(QString().sprintf("<DRM_OS2FILE,%s>",
     852                                          drf.data()).toLocal8Bit());
    852853    HSTR rmfSharedMem =
    853         DrgAddStrHandle(QString().sprintf("<DRM_SHAREDMEM,%s>", drf).toLocal8Bit());
     854        DrgAddStrHandle(QString().sprintf("<DRM_SHAREDMEM,%s>",
     855                                          drf.data()).toLocal8Bit());
    854856
    855857    MRESULT mrc;
    … …  
    18151817#endif // !QT_NO_DRAGANDDROP
    18161818
    1817 ////////////////////////////////////////////////////////////////////////////////
     1819//------------------------------------------------------------------------------
    18181820
    18191821class QPMMimeText : public QPMMime
    … …  
    18731875        bool provide(const char *drf, const QByteArray &allData,
    18741876                     ULONG itemIndex, QByteArray &itemData);
    1875         void fileType(const char *drf, const char *&type, const char *&ext);
     1877        void fileType(const char *drf, QString &type, QString &ext);
    18761878    };
    18771879
    … …  
    18801882    public:
    18811883        // Provider interface
    1882         const char *drf(const QString &mimeType) const;
    1883         bool provide(const QString &format, ULONG itemIndex,
     1884        QByteArray drf(const QString &mimeType) const;
     1885        bool provide(const QString &mimeType, ULONG itemIndex,
    18841886                     const QByteArray &itemData, QByteArray &allData);
    18851887    };
    … …  
    22462248}
    22472249
    2248 void QPMMimeText::TextDragProvider::fileType(const char *drf, const char *&type,
    2249                                              const char *&ext)
     2250void QPMMimeText::TextDragProvider::fileType(const char *drf,
     2251                                             QString &type, QString &ext)
    22502252{
    22512253    if (qstrcmp(drf, "DRF_TEXT") == 0) {
    22522254        if (exclusive) {
    2253             type = "UniformResourceLocator";
     2255            type = QLatin1String("UniformResourceLocator");
    22542256            // no extension for URLs
     2257            ext = QString::null;
    22552258        } else {
    2256             type = DRT_TEXT;
    2257             ext = "txt";
     2259            type = QLatin1String(DRT_TEXT);
     2260            ext = QLatin1String("txt");
    22582261        }
    22592262    }
    22602263};
    22612264
    2262 const char *QPMMimeText::TextDropProvider::drf(const QString &mimeType) const
     2265QByteArray QPMMimeText::TextDropProvider::drf(const QString &mimeType) const
    22632266{
    22642267    // sanity check
    22652268    if (mimeType == QLatin1String("text/plain") ||
    22662269        mimeType == QLatin1String("text/uri-list"))
    2267         return "DRF_TEXT";
     2270        return QByteArray("DRF_TEXT");
    22682271    return 0;
    22692272}
    … …  
    24002403#endif // !QT_NO_DRAGANDDROP
    24012404
    2402 ////////////////////////////////////////////////////////////////////////////////
     2405//------------------------------------------------------------------------------
    24032406
    24042407class QPMMimeImage : public QPMMime
    … …  
    24892492}
    24902493
    2491 ////////////////////////////////////////////////////////////////////////////////
     2494//------------------------------------------------------------------------------
    24922495
    24932496class QPMMimeAnyMime : public QPMMime
    … …  
    25072510                               QVariant::Type preferredType) const;
    25082511
     2512#if !defined(QT_NO_DRAGANDDROP)
     2513
     2514    // Direct Manipulation (DND) converter interface
     2515    DragWorker *dragWorkerFor(const QString &mimeType, QMimeData *mimeData);
     2516    DropWorker *dropWorkerFor(DRAGINFO *info);
     2517
     2518    class AnyDragProvider : public DefaultDragWorker::Provider
     2519    {
     2520    public:
     2521        AnyDragProvider(QPMMimeAnyMime *am) : anyMime(am) {}
     2522        // Provider interface
     2523        QString format(const char *drf) const;
     2524        bool provide(const char *drf, const QByteArray &allData,
     2525                     ULONG itemIndex, QByteArray &itemData);
     2526        void fileType(const char *drf, QString &type, QString &ext);
     2527    private:
     2528        QPMMimeAnyMime *anyMime;
     2529    };
     2530
     2531    class AnyDropProvider : public DefaultDropWorker::Provider
     2532    {
     2533    public:
     2534        AnyDropProvider(QPMMimeAnyMime *am) : anyMime(am) {}
     2535        // Provider interface
     2536        QByteArray drf(const QString &mimeType) const;
     2537        bool provide(const QString &mimeType, ULONG itemIndex,
     2538                     const QByteArray &itemData, QByteArray &allData);
     2539    private:
     2540        QPMMimeAnyMime *anyMime;
     2541    };
     2542
     2543#endif // !QT_NO_DRAGANDDROP
     2544
    25092545private:
    25102546    ULONG registerMimeType(const QString &mime) const;
    … …  
    25172553    static QString mimePrefix;
    25182554    static QString customPrefix;
     2555
     2556#if !defined(QT_NO_DRAGANDDROP)
     2557
     2558    static ULONG drfToCf(const char *drf);
     2559    static QByteArray cfToDrf(ULONG cf);
     2560
     2561    AnyDragProvider anyDragProvider;
     2562    AnyDropProvider anyDropProvider;
     2563
     2564//    friend class AnyDragProvider;
     2565//    friend class AnyDropProvider;
     2566
     2567#endif // !QT_NO_DRAGANDDROP
    25192568};
    25202569
    … …  
    25252574
    25262575QPMMimeAnyMime::QPMMimeAnyMime()
     2576#if !defined(QT_NO_DRAGANDDROP)
     2577    : anyDragProvider(AnyDragProvider(this))
     2578    , anyDropProvider(AnyDropProvider(this))
     2579#endif // !QT_NO_DRAGANDDROP
    25272580{
    25282581    //MIME Media-Types
    … …  
    26372690}
    26382691
     2692#if !defined(QT_NO_DRAGANDDROP)
     2693
     2694QString QPMMimeAnyMime::AnyDragProvider::format(const char *drf) const
     2695{
     2696    ULONG cf = drfToCf(drf);
     2697    if (cf) {
     2698        QString mime = anyMime->mimeMap.value(cf);
     2699        if (!mime.isEmpty())
     2700            return mime;
     2701    }
     2702
     2703    // There must always be a match since the given drf is associated with this
     2704    // provider by dragWorkerFor() and all necessary mappings are there.
     2705    Q_ASSERT(false);
     2706    return QString::null;
     2707}
     2708
     2709bool QPMMimeAnyMime::AnyDragProvider::provide(const char *drf,
     2710                                              const QByteArray &allData,
     2711                                              ULONG itemIndex,
     2712                                              QByteArray &itemData)
     2713{
     2714    Q_UNUSED(drf);
     2715    Q_UNUSED(itemIndex);
     2716
     2717    // always straight through coversion
     2718    itemData = allData;
     2719    return true;
     2720}
     2721
     2722void QPMMimeAnyMime::AnyDragProvider::fileType(const char *drf,
     2723                                               QString &type, QString &ext)
     2724{
     2725    // file type = mime
     2726    type = format(drf);
     2727    Q_ASSERT(!type.isEmpty());
     2728
     2729    // no way to determine the extension
     2730    ext = QString::null;
     2731};
     2732
     2733QByteArray QPMMimeAnyMime::AnyDropProvider::drf(const QString &mimeType) const
     2734{
     2735    ULONG cf = anyMime->cfMap.value(mimeType);
     2736    if (cf)
     2737        return cfToDrf(cf);
     2738
     2739    // There must always be a match since the given drf is associated with this
     2740    // provider by dragWorkerFor() and all necessary mappings are there.
     2741    Q_ASSERT(false);
     2742    return QByteArray();
     2743}
     2744
     2745bool QPMMimeAnyMime::AnyDropProvider::provide(const QString &mimeType,
     2746                                              ULONG itemIndex,
     2747                                              const QByteArray &itemData,
     2748                                              QByteArray &allData)
     2749{
     2750    Q_UNUSED(mimeType);
     2751    Q_UNUSED(itemIndex);
     2752
     2753    // always straight through coversion
     2754    allData = itemData;
     2755    return true;
     2756}
     2757
     2758QPMMime::DragWorker *QPMMimeAnyMime::dragWorkerFor(const QString &mimeType,
     2759                                                   QMimeData *mimeData)
     2760{
     2761    ULONG cf = cfMap.value(mimeType);
     2762    if (!cf)
     2763        cf = registerMimeType(mimeType);
     2764    if (cf) {
     2765        DefaultDragWorker *defWorker = defaultCoopDragWorker();
     2766        // add a cooperative provider
     2767        defWorker->addProvider(cfToDrf(cf), &anyDragProvider);
     2768        return defWorker;
     2769    }
     2770
     2771    Q_ASSERT(false);
     2772    return 0;
     2773}
     2774
     2775QPMMime::DropWorker *QPMMimeAnyMime::dropWorkerFor(DRAGINFO *info)
     2776{
     2777    ULONG itemCount = DrgQueryDragitemCount(info);
     2778    Q_ASSERT(itemCount);
     2779    if (!itemCount)
     2780        return 0;
     2781
     2782    if (itemCount == 1) {
     2783        DRAGITEM *item = DrgQueryDragitemPtr(info, 0);
     2784        Q_ASSERT(item);
     2785        if (!item)
     2786            return 0;
     2787
     2788        DefaultDropWorker *defWorker = defaultDropWorker();
     2789        bool atLeastOneSupported = false;
     2790
     2791        // check that we support one of DRMs and the format is CF_hhhhhhh
     2792        QList<QByteArrayList> list;
     2793        defWorker->getSupportedRMFs(item, list);
     2794        foreach(const QByteArrayList &mech, list) {
     2795            QByteArrayList::const_iterator it = mech.begin();
     2796            Q_ASSERT(it != mech.end());
     2797            DEBUG(() << "QPMMimeAnyMime: Supported drm:" << *it);
     2798            for (++it; it != mech.end(); ++it) {
     2799                const QByteArray &drf = *it;
     2800                ULONG cf = drfToCf(drf);
     2801                if (cf) {
     2802                    DEBUG(() << "QPMMimeAnyMime: Supported drf:" << drf);
     2803                    QString mime = mimeMap.value(cf);
     2804                    if (mime.isEmpty())
     2805                        mime = registerFormat(cf);
     2806                    Q_ASSERT(!mime.isEmpty());
     2807                    if (!mime.isEmpty()) {
     2808                        DEBUG(() << "QPMMimeAnyMime: Will provide [" << mime
     2809                                 << "] for drf" << drf);
     2810                        // add a cooperative provider (can coexist with others)
     2811                        defWorker->addProvider(mime, &anyDropProvider);
     2812                        atLeastOneSupported = true;
     2813                    }
     2814                }
     2815            }
     2816        }
     2817
     2818        if (atLeastOneSupported)
     2819            return defWorker;
     2820    }
     2821
     2822    return 0;
     2823}
     2824
     2825#endif // !QT_NO_DRAGANDDROP
     2826
    26392827ULONG QPMMimeAnyMime::registerMimeType(const QString &mime) const
    26402828{
    … …  
    26892877}
    26902878
    2691 ////////////////////////////////////////////////////////////////////////////////
     2879#if !defined(QT_NO_DRAGANDDROP)
     2880
     2881// static
     2882ULONG QPMMimeAnyMime::drfToCf(const char *drf)
     2883{
     2884    if (qstrncmp(drf, "CF_", 3) == 0)
     2885        return QString(QLatin1String(drf + 3)).toULong(0, 16);
     2886    return 0;
     2887}
     2888
     2889// static
     2890QByteArray QPMMimeAnyMime::cfToDrf(ULONG cf)
     2891{
     2892    return QString().sprintf("CF_%08lX", cf).toLatin1();
     2893}
     2894
     2895#endif // !QT_NO_DRAGANDDROP
     2896
     2897//------------------------------------------------------------------------------
    26922898
    26932899QPMMimeList::QPMMimeList()
Note: See TracChangeset for help on using the changeset viewer.