Changeset 332 for trunk/src

Timestamp:

Nov 20, 2009, 2:53:36 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui/kernel: mime: Implemented mime->clipboard interface for "text/plain" (only putting to the system clipboard so far).

Location:

trunk/src/gui/kernel

Files:

• qmime.h (modified) (1 diff)
• qmime_pm.cpp (modified) (5 diffs)

trunk/src/gui/kernel/qmime.h

@@ -134 +134 @@
 
     static ULONG registerMimeType(const QString &mime);
+
+    static ULONG allocateMemory(size_t size);
+    static void freeMemory(ULONG addr);
 
 private:

trunk/src/gui/kernel/qmime_pm.cpp

@@ -136 +136 @@
 /*!
     Registers the MIME type \a mime, and returns an ID number
-    identifying the format on OS/2.
-*/
+    identifying the format on OS/2. Intended to be used by QPMMime
+    implementations for registering custom clipboard formats they use.
+*/
+// static
 ULONG QPMMime::registerMimeType(const QString &mime)
 {
-    QString atom = QLatin1String("mime:") + mime;
-
-    ULONG cf = WinAddAtom(WinQuerySystemAtomTable(), atom.toLocal8Bit());
+    ULONG cf = WinAddAtom(WinQuerySystemAtomTable(), mime.toLocal8Bit());
     if (!cf) {
 #ifndef QT_NO_DEBUG
@@ -155 +155 @@
 
 /*!
+    Allocates a block of shared memory of the given size and returns the address
+    of this block. This memory block may be then filled with data and returned
+    by convertFromMimeData() as the value of the CFI_POINTER type.
+*/
+// static
+ULONG QPMMime::allocateMemory(size_t size)
+{
+    if (size == 0)
+        return 0;
+
+    ULONG data = 0;
+
+    // allocate giveable memory for the array + dword for its size
+    APIRET arc = DosAllocSharedMem((PVOID *)&data, NULL, size + 4,
+                                   PAG_WRITE  | PAG_COMMIT | OBJ_GIVEABLE);
+    if (arc != NO_ERROR) {
+#ifndef QT_NO_DEBUG
+        qWarning("QPMMime::allocateMemory: DosAllocSharedMem failed with %lu", arc);
+#endif
+        return 0;
+    }
+    // get the size rounded to the page boundary (4K)
+    ULONG sz = ~0, flags = 0;
+    arc = DosQueryMem((PVOID)(data + size - 1), &sz, &flags);
+    if (arc != NO_ERROR) {
+#ifndef QT_NO_DEBUG
+        qWarning("QPMMime::allocateMemory: DosQueryMem failed with %lu", arc);
+#endif
+        DosFreeMem((PVOID)data);
+        return 0;
+    }
+    sz += (size - 1);
+    // store the exact size to the last dword of the last page
+    *(((ULONG *)(data + sz)) - 1) = size;
+
+    return data;
+}
+
+/*!
+    Frees memory allocated by allocateMemory(). Normally, not used because the
+    CFI_POINTER memory blocks are owned by the system after
+    convertFromMimeData() returns.
+*/
+// static
+void QPMMime::freeMemory(ULONG addr)
+{
+    DosFreeMem((PVOID)addr);
+}
+
+/*!
     \fn QList<ULONG> QPMMime::formatsForMimeData(const QMimeData *mimeData) const
 
@@ -180 +230 @@
     \table
     \row \o \c CFI_POINTER        \o \a data is a pointer to a block of memory
-                                      allocated with QPMMime::allocMem()
+                                      allocated with QPMMime::allocateMemory()
     \row \o \c CFI_HANDLE         \o \a data is a handle to the appropriate
                                       PM resource
@@ -285 +335 @@
 ////////////////////////////////////////////////////////////////////////////////
 
+class QPMMimeText : public QPMMime
+{
+public:
+    QPMMimeText();
+
+    QList<ULONG> formatsForMimeData(const QMimeData *mimeData) const;
+    bool convertFromMimeData(const QMimeData *mimeData, ULONG format,
+                             ULONG &flags, ULONG *data) const;
+
+    QStringList mimesForFormats(const QList<ULONG> &formats) const;
+    QVariant convertFromFormat(ULONG format, ULONG flags, ULONG data,
+                               const QString &mimeType,
+                               QVariant::Type preferredType) const;
+
+    const ULONG CF_TextUnicode;
+};
+
+QPMMimeText::QPMMimeText()
+    // "text/unicode" is what Mozilla uses to for unicode, so Qt apps will
+    // be able to interchange unicode text with Mozilla apps
+    : CF_TextUnicode (registerMimeType(QLatin1String("text/unicode")))
+{
+}
+
+QList<ULONG> QPMMimeText::formatsForMimeData(const QMimeData *mimeData) const
+{
+    QList<ULONG> cfs;
+    if (mimeData->hasText())
+        cfs << CF_TEXT << CF_TextUnicode;
+    return cfs;
+}
+
+// text/plain is defined as using CRLF, but so many programs don't,
+// and programmers just look for '\n' in strings.
+// OS/2 really needs CRLF, so we ensure it here.
+bool QPMMimeText::convertFromMimeData(const QMimeData *mimeData, ULONG format,
+                                      ULONG &flags, ULONG *data) const
+{
+    if (!mimeData->hasText())
+        return false;
+
+    flags = CFI_POINTER;
+
+    if (data == NULL)
+        return true; // delayed rendering, nothing to do
+
+    QByteArray r;
+
+    if (format == CF_TEXT) {
+        QByteArray str = mimeData->text().toLocal8Bit();
+        // Anticipate required space for CRLFs at 1/40
+        int maxsize = str.size()+str.size()/40+3;
+        r.fill('\0', maxsize);
+        char* o = r.data();
+        const char* d = str.data();
+        const int s = str.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;
+    } else if (format == CF_TextUnicode) {
+        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()*2;
+        r.fill('\0', byteLength + 2);
+        memcpy(r.data(), res.unicode(), byteLength);
+        r[byteLength] = 0;
+        r[byteLength+1] = 0;
+    } else{
+        return false;
+    }
+
+    *data = QPMMime::allocateMemory(r.size());
+    if (!*data)
+        return false;
+
+    memcpy((void *)*data, r.data(), r.size());
+    return true;
+}
+
+QStringList QPMMimeText::mimesForFormats(const QList<ULONG> &formats) const
+{
+    QStringList mimes;
+    foreach(ULONG cf, formats) {
+        if (cf == CF_TEXT || cf == CF_TextUnicode){
+            mimes << QLatin1String("text/plain");
+            break;
+        }
+    }
+    return mimes;
+}
+
+QVariant QPMMimeText::convertFromFormat(ULONG format, ULONG flags, ULONG data,
+                                        const QString &mimeType,
+                                        QVariant::Type preferredType) const
+{
+    return QVariant();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -303 +491 @@
     if (!initialized) {
         initialized = true;
-        // @todo new QPMMimeXXX;
+        new QPMMimeText;
     }
 }