source: trunk/src/gui/kernel/qmime_mac.cpp

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 44.7 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2011 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** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
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** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "qmime.h"
43
44//#define USE_INTERNET_CONFIG
45
46#ifndef USE_INTERNET_CONFIG
47# include "qfile.h"
48# include "qfileinfo.h"
49# include "qtextstream.h"
50# include "qdir.h"
51# include <unistd.h>
52# include <sys/types.h>
53# include <sys/stat.h>
54# include <sys/fcntl.h>
55#endif
56
57#include "qdebug.h"
58#include "qpixmap.h"
59#include "qimagewriter.h"
60#include "qimagereader.h"
61#include "qdatastream.h"
62#include "qbuffer.h"
63#include "qdatetime.h"
64#include "qapplication_p.h"
65#include "qtextcodec.h"
66#include "qregexp.h"
67#include "qurl.h"
68#include "qmap.h"
69#include <private/qt_mac_p.h>
70
71
72#ifdef Q_WS_MAC32
73#include <QuickTime/QuickTime.h>
74#include <qlibrary.h>
75#endif
76
77QT_BEGIN_NAMESPACE
78
79extern CGImageRef qt_mac_createCGImageFromQImage(const QImage &img, const QImage **imagePtr = 0); // qpaintengine_mac.cpp
80
81typedef QList<QMacPasteboardMime*> MimeList;
82Q_GLOBAL_STATIC(MimeList, globalMimeList)
83
84static void cleanup_mimes()
85{
86 MimeList *mimes = globalMimeList();
87 while (!mimes->isEmpty())
88 delete mimes->takeFirst();
89}
90
91Q_GLOBAL_STATIC(QStringList, globalDraggedTypesList)
92
93/*!
94 \fn void qRegisterDraggedTypes(const QStringList &types)
95 \relates QMacPasteboardMime
96
97 Registers the given \a types as custom pasteboard types.
98
99 This function should be called to enable the Drag and Drop events
100 for custom pasteboard types on Cocoa implementations. This is required
101 in addition to a QMacPasteboardMime subclass implementation. By default
102 drag and drop is enabled for all standard pasteboard types.
103
104 \sa QMacPasteboardMime
105*/
106Q_GUI_EXPORT void qRegisterDraggedTypes(const QStringList &types)
107{
108 (*globalDraggedTypesList()) += types;
109}
110
111const QStringList& qEnabledDraggedTypes()
112{
113 return (*globalDraggedTypesList());
114}
115
116
117/*****************************************************************************
118 QDnD debug facilities
119 *****************************************************************************/
120//#define DEBUG_MIME_MAPS
121
122//functions
123extern QString qt_mac_from_pascal_string(const Str255); //qglobal.cpp
124extern void qt_mac_from_pascal_string(QString, Str255, TextEncoding encoding=0, int len=-1); //qglobal.cpp
125
126ScrapFlavorType qt_mac_mime_type = 'CUTE';
127CFStringRef qt_mac_mime_typeUTI = CFSTR("com.pasteboard.trolltech.marker");
128
129/*!
130 \class QMacPasteboardMime
131 \brief The QMacPasteboardMime class converts between a MIME type and a
132 \l{http://developer.apple.com/macosx/uniformtypeidentifiers.html}{Uniform
133 Type Identifier (UTI)} format.
134 \since 4.2
135
136 \ingroup draganddrop
137
138 Qt's drag and drop and clipboard facilities use the MIME
139 standard. On X11, this maps trivially to the Xdnd protocol. On
140 Mac, although some applications use MIME to describe clipboard
141 contents, it is more common to use Apple's UTI format.
142
143 QMacPasteboardMime's role is to bridge the gap between MIME and UTI;
144 By subclasses this class, one can extend Qt's drag and drop
145 and clipboard handling to convert to and from unsupported, or proprietary, UTI formats.
146
147 A subclass of QMacPasteboardMime will automatically be registered, and active, upon instantiation.
148
149 Qt has predefined support for the following UTIs:
150 \list
151 \i public.utf8-plain-text - converts to "text/plain"
152 \i public.utf16-plain-text - converts to "text/plain"
153 \i public.html - converts to "text/html"
154 \i public.url - converts to "text/uri-list"
155 \i public.file-url - converts to "text/uri-list"
156 \i public.tiff - converts to "application/x-qt-image"
157 \i public.vcard - converts to "text/plain"
158 \i com.apple.traditional-mac-plain-text - converts to "text/plain"
159 \i com.apple.pict - converts to "application/x-qt-image"
160 \endlist
161
162 When working with MIME data, Qt will interate through all instances of QMacPasteboardMime to
163 find an instance that can convert to, or from, a specific MIME type. It will do this by calling
164 canConvert() on each instance, starting with (and choosing) the last created instance first.
165 The actual conversions will be done by using convertToMime() and convertFromMime().
166
167 \note The API uses the term "flavor" in some cases. This is for backwards
168 compatibility reasons, and should now be understood as UTIs.
169*/
170
171/*! \enum QMacPasteboardMime::QMacPasteboardMimeType
172 \internal
173*/
174
175/*!
176 Constructs a new conversion object of type \a t, adding it to the
177 globally accessed list of available convertors.
178*/
179QMacPasteboardMime::QMacPasteboardMime(char t) : type(t)
180{
181 globalMimeList()->append(this);
182}
183
184/*!
185 Destroys a conversion object, removing it from the global
186 list of available convertors.
187*/
188QMacPasteboardMime::~QMacPasteboardMime()
189{
190 if(!QApplication::closingDown())
191 globalMimeList()->removeAll(this);
192}
193
194class QMacPasteboardMimeAny : public QMacPasteboardMime {
195private:
196
197public:
198 QMacPasteboardMimeAny() : QMacPasteboardMime(MIME_QT_CONVERTOR|MIME_ALL) {
199 }
200 ~QMacPasteboardMimeAny() {
201 }
202 QString convertorName();
203
204 QString flavorFor(const QString &mime);
205 QString mimeFor(QString flav);
206 bool canConvert(const QString &mime, QString flav);
207 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
208 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
209};
210
211QString QMacPasteboardMimeAny::convertorName()
212{
213 return QLatin1String("Any-Mime");
214}
215
216QString QMacPasteboardMimeAny::flavorFor(const QString &mime)
217{
218 // do not handle the mime type name in the drag pasteboard
219 if(mime == QLatin1String("application/x-qt-mime-type-name"))
220 return QString();
221 QString ret = QLatin1String("com.trolltech.anymime.") + mime;
222 return ret.replace(QLatin1Char('/'), QLatin1String("--"));
223}
224
225QString QMacPasteboardMimeAny::mimeFor(QString flav)
226{
227 const QString any_prefix = QLatin1String("com.trolltech.anymime.");
228 if(flav.size() > any_prefix.length() && flav.startsWith(any_prefix))
229 return flav.mid(any_prefix.length()).replace(QLatin1String("--"), QLatin1String("/"));
230 return QString();
231}
232
233bool QMacPasteboardMimeAny::canConvert(const QString &mime, QString flav)
234{
235 return mimeFor(flav) == mime;
236}
237
238QVariant QMacPasteboardMimeAny::convertToMime(const QString &mime, QList<QByteArray> data, QString)
239{
240 if(data.count() > 1)
241 qWarning("QMacPasteboardMimeAny: Cannot handle multiple member data");
242 QVariant ret;
243 if (mime == QLatin1String("text/plain"))
244 ret = QString::fromUtf8(data.first());
245 else
246 ret = data.first();
247 return ret;
248}
249
250QList<QByteArray> QMacPasteboardMimeAny::convertFromMime(const QString &mime, QVariant data, QString)
251{
252 QList<QByteArray> ret;
253 if (mime == QLatin1String("text/plain"))
254 ret.append(data.toString().toUtf8());
255 else
256 ret.append(data.toByteArray());
257 return ret;
258}
259
260class QMacPasteboardMimeTypeName : public QMacPasteboardMime {
261private:
262
263public:
264 QMacPasteboardMimeTypeName() : QMacPasteboardMime(MIME_QT_CONVERTOR|MIME_ALL) {
265 }
266 ~QMacPasteboardMimeTypeName() {
267 }
268 QString convertorName();
269
270 QString flavorFor(const QString &mime);
271 QString mimeFor(QString flav);
272 bool canConvert(const QString &mime, QString flav);
273 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
274 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
275};
276
277QString QMacPasteboardMimeTypeName::convertorName()
278{
279 return QLatin1String("Qt-Mime-Type");
280}
281
282QString QMacPasteboardMimeTypeName::flavorFor(const QString &mime)
283{
284 if(mime == QLatin1String("application/x-qt-mime-type-name"))
285 return QLatin1String("com.trolltech.qt.MimeTypeName");
286 return QString();
287}
288
289QString QMacPasteboardMimeTypeName::mimeFor(QString)
290{
291 return QString();
292}
293
294bool QMacPasteboardMimeTypeName::canConvert(const QString &, QString)
295{
296 return false;
297}
298
299QVariant QMacPasteboardMimeTypeName::convertToMime(const QString &, QList<QByteArray>, QString)
300{
301 QVariant ret;
302 return ret;
303}
304
305QList<QByteArray> QMacPasteboardMimeTypeName::convertFromMime(const QString &, QVariant, QString)
306{
307 QList<QByteArray> ret;
308 ret.append(QString("x-qt-mime-type-name").toUtf8());
309 return ret;
310}
311
312class QMacPasteboardMimePlainText : public QMacPasteboardMime {
313public:
314 QMacPasteboardMimePlainText() : QMacPasteboardMime(MIME_ALL) { }
315 QString convertorName();
316
317 QString flavorFor(const QString &mime);
318 QString mimeFor(QString flav);
319 bool canConvert(const QString &mime, QString flav);
320 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
321 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
322};
323
324QString QMacPasteboardMimePlainText::convertorName()
325{
326 return QLatin1String("PlainText");
327}
328
329QString QMacPasteboardMimePlainText::flavorFor(const QString &mime)
330{
331 if (mime == QLatin1String("text/plain"))
332 return QLatin1String("com.apple.traditional-mac-plain-text");
333 return QString();
334}
335
336QString QMacPasteboardMimePlainText::mimeFor(QString flav)
337{
338 if (flav == QLatin1String("com.apple.traditional-mac-plain-text"))
339 return QLatin1String("text/plain");
340 return QString();
341}
342
343bool QMacPasteboardMimePlainText::canConvert(const QString &mime, QString flav)
344{
345 return flavorFor(mime) == flav;
346}
347
348QVariant QMacPasteboardMimePlainText::convertToMime(const QString &mimetype, QList<QByteArray> data, QString flavor)
349{
350 if(data.count() > 1)
351 qWarning("QMacPasteboardMimePlainText: Cannot handle multiple member data");
352 const QByteArray &firstData = data.first();
353 QVariant ret;
354 if(flavor == QCFString(QLatin1String("com.apple.traditional-mac-plain-text"))) {
355 QCFString str(CFStringCreateWithBytes(kCFAllocatorDefault,
356 reinterpret_cast<const UInt8 *>(firstData.constData()),
357 firstData.size(), CFStringGetSystemEncoding(), false));
358 ret = QString(str);
359 } else {
360 qWarning("QMime::convertToMime: unhandled mimetype: %s", qPrintable(mimetype));
361 }
362 return ret;
363}
364
365QList<QByteArray> QMacPasteboardMimePlainText::convertFromMime(const QString &, QVariant data, QString flavor)
366{
367 QList<QByteArray> ret;
368 QString string = data.toString();
369 if(flavor == QCFString(QLatin1String("com.apple.traditional-mac-plain-text")))
370 ret.append(string.toLatin1());
371 return ret;
372}
373
374class QMacPasteboardMimeUnicodeText : public QMacPasteboardMime {
375public:
376 QMacPasteboardMimeUnicodeText() : QMacPasteboardMime(MIME_ALL) { }
377 QString convertorName();
378
379 QString flavorFor(const QString &mime);
380 QString mimeFor(QString flav);
381 bool canConvert(const QString &mime, QString flav);
382 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
383 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
384};
385
386QString QMacPasteboardMimeUnicodeText::convertorName()
387{
388 return QLatin1String("UnicodeText");
389}
390
391QString QMacPasteboardMimeUnicodeText::flavorFor(const QString &mime)
392{
393 if (mime == QLatin1String("text/plain"))
394 return QLatin1String("public.utf16-plain-text");
395 int i = mime.indexOf(QLatin1String("charset="));
396 if (i >= 0) {
397 QString cs(mime.mid(i+8).toLower());
398 i = cs.indexOf(QLatin1Char(';'));
399 if (i>=0)
400 cs = cs.left(i);
401 if (cs == QLatin1String("system"))
402 return QLatin1String("public.utf8-plain-text");
403 else if (cs == QLatin1String("iso-10646-ucs-2")
404 || cs == QLatin1String("utf16"))
405 return QLatin1String("public.utf16-plain-text");
406 }
407 return QString();
408}
409
410QString QMacPasteboardMimeUnicodeText::mimeFor(QString flav)
411{
412 if (flav == QLatin1String("public.utf16-plain-text") || flav == QLatin1String("public.utf8-plain-text"))
413 return QLatin1String("text/plain");
414 return QString();
415}
416
417bool QMacPasteboardMimeUnicodeText::canConvert(const QString &mime, QString flav)
418{
419 return flavorFor(mime) == flav;
420}
421
422QVariant QMacPasteboardMimeUnicodeText::convertToMime(const QString &mimetype, QList<QByteArray> data, QString flavor)
423{
424 if(data.count() > 1)
425 qWarning("QMacPasteboardMimeUnicodeText: Cannot handle multiple member data");
426 const QByteArray &firstData = data.first();
427 // I can only handle two types (system and unicode) so deal with them that way
428 QVariant ret;
429 if(flavor == QLatin1String("public.utf8-plain-text")) {
430 QCFString str(CFStringCreateWithBytes(kCFAllocatorDefault,
431 reinterpret_cast<const UInt8 *>(firstData.constData()),
432 firstData.size(), CFStringGetSystemEncoding(), false));
433 ret = QString(str);
434 } else if (flavor == QLatin1String("public.utf16-plain-text")) {
435 ret = QString(reinterpret_cast<const QChar *>(firstData.constData()),
436 firstData.size() / sizeof(QChar));
437 } else {
438 qWarning("QMime::convertToMime: unhandled mimetype: %s", qPrintable(mimetype));
439 }
440 return ret;
441}
442
443QList<QByteArray> QMacPasteboardMimeUnicodeText::convertFromMime(const QString &, QVariant data, QString flavor)
444{
445 QList<QByteArray> ret;
446 QString string = data.toString();
447 if(flavor == QLatin1String("public.utf8-plain-text"))
448 ret.append(string.toUtf8());
449 else if (flavor == QLatin1String("public.utf16-plain-text"))
450 ret.append(QByteArray((char*)string.utf16(), string.length()*2));
451 return ret;
452}
453
454class QMacPasteboardMimeHTMLText : public QMacPasteboardMime {
455public:
456 QMacPasteboardMimeHTMLText() : QMacPasteboardMime(MIME_ALL) { }
457 QString convertorName();
458
459 QString flavorFor(const QString &mime);
460 QString mimeFor(QString flav);
461 bool canConvert(const QString &mime, QString flav);
462 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
463 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
464};
465
466QString QMacPasteboardMimeHTMLText::convertorName()
467{
468 return QLatin1String("HTML");
469}
470
471QString QMacPasteboardMimeHTMLText::flavorFor(const QString &mime)
472{
473 if (mime == QLatin1String("text/html"))
474 return QLatin1String("public.html");
475 return QString();
476}
477
478QString QMacPasteboardMimeHTMLText::mimeFor(QString flav)
479{
480 if (flav == QLatin1String("public.html"))
481 return QLatin1String("text/html");
482 return QString();
483}
484
485bool QMacPasteboardMimeHTMLText::canConvert(const QString &mime, QString flav)
486{
487 return flavorFor(mime) == flav;
488}
489
490QVariant QMacPasteboardMimeHTMLText::convertToMime(const QString &mimeType, QList<QByteArray> data, QString flavor)
491{
492 if (!canConvert(mimeType, flavor))
493 return QVariant();
494 if (data.count() > 1)
495 qWarning("QMacPasteboardMimeHTMLText: Cannot handle multiple member data");
496 return data.first();
497}
498
499QList<QByteArray> QMacPasteboardMimeHTMLText::convertFromMime(const QString &mime, QVariant data, QString flavor)
500{
501 QList<QByteArray> ret;
502 if (!canConvert(mime, flavor))
503 return ret;
504 ret.append(data.toByteArray());
505 return ret;
506}
507
508
509#ifdef Q_WS_MAC32
510
511// This can be removed once 10.6 is the minimum (or we have to require 64-bit) whichever comes first.
512
513typedef ComponentResult (*PtrGraphicsImportSetDataHandle)(GraphicsImportComponent, Handle);
514typedef ComponentResult (*PtrGraphicsImportCreateCGImage)(GraphicsImportComponent, CGImageRef*, UInt32);
515typedef ComponentResult (*PtrGraphicsExportSetInputCGImage)(GraphicsExportComponent, CGImageRef);
516typedef ComponentResult (*PtrGraphicsExportSetOutputHandle)(GraphicsExportComponent, Handle);
517typedef ComponentResult (*PtrGraphicsExportDoExport)(GraphicsExportComponent, unsigned long *);
518
519static PtrGraphicsImportSetDataHandle ptrGraphicsImportSetDataHandle = 0;
520static PtrGraphicsImportCreateCGImage ptrGraphicsImportCreateCGImage = 0;
521static PtrGraphicsExportSetInputCGImage ptrGraphicsExportSetInputCGImage = 0;
522static PtrGraphicsExportSetOutputHandle ptrGraphicsExportSetOutputHandle = 0;
523static PtrGraphicsExportDoExport ptrGraphicsExportDoExport = 0;
524
525static bool resolveMimeQuickTimeSymbols()
526{
527 if (ptrGraphicsImportSetDataHandle == 0) {
528 QLibrary library(QLatin1String("/System/Library/Frameworks/QuickTime.framework/QuickTime"));
529 ptrGraphicsImportSetDataHandle = reinterpret_cast<PtrGraphicsImportSetDataHandle>(library.resolve("GraphicsImportSetDataHandle"));
530 ptrGraphicsImportCreateCGImage = reinterpret_cast<PtrGraphicsImportCreateCGImage>(library.resolve("GraphicsImportCreateCGImage"));
531 ptrGraphicsExportSetInputCGImage = reinterpret_cast<PtrGraphicsExportSetInputCGImage>(library.resolve("GraphicsExportSetInputCGImage"));
532 ptrGraphicsExportSetOutputHandle = reinterpret_cast<PtrGraphicsExportSetOutputHandle>(library.resolve("GraphicsExportSetOutputHandle"));
533 ptrGraphicsExportDoExport = reinterpret_cast<PtrGraphicsExportDoExport>(library.resolve("GraphicsExportDoExport"));
534 }
535
536 return ptrGraphicsImportSetDataHandle != 0
537 && ptrGraphicsImportCreateCGImage != 0 && ptrGraphicsExportSetInputCGImage != 0
538 && ptrGraphicsExportSetOutputHandle != 0 && ptrGraphicsExportDoExport != 0;
539}
540
541class QMacPasteboardMimePict : public QMacPasteboardMime {
542public:
543 QMacPasteboardMimePict() : QMacPasteboardMime(MIME_ALL) { }
544 QString convertorName();
545
546 QString flavorFor(const QString &mime);
547 QString mimeFor(QString flav);
548 bool canConvert(const QString &mime, QString flav);
549 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
550 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
551};
552
553QString QMacPasteboardMimePict::convertorName()
554{
555 return QLatin1String("Pict");
556}
557
558QString QMacPasteboardMimePict::flavorFor(const QString &mime)
559{
560 if(mime.startsWith(QLatin1String("application/x-qt-image")))
561 return QLatin1String("com.apple.pict");
562 return QString();
563}
564
565QString QMacPasteboardMimePict::mimeFor(QString flav)
566{
567 if(flav == QLatin1String("com.apple.pict"))
568 return QLatin1String("application/x-qt-image");
569 return QString();
570}
571
572bool QMacPasteboardMimePict::canConvert(const QString &mime, QString flav)
573{
574 return flav == QLatin1String("com.apple.pict")
575 && mime == QLatin1String("application/x-qt-image");
576}
577
578
579QVariant QMacPasteboardMimePict::convertToMime(const QString &mime, QList<QByteArray> data, QString flav)
580{
581 if(data.count() > 1)
582 qWarning("QMacPasteboardMimePict: Cannot handle multiple member data");
583 QVariant ret;
584 if (!resolveMimeQuickTimeSymbols())
585 return ret;
586
587 if(!canConvert(mime, flav))
588 return ret;
589 const QByteArray &a = data.first();
590
591 // This function expects the 512 header (just to skip it, so create the extra space for it).
592 Handle pic = NewHandle(a.size() + 512);
593 memcpy(*pic + 512, a.constData(), a.size());
594
595 GraphicsImportComponent graphicsImporter;
596 ComponentResult result = OpenADefaultComponent(GraphicsImporterComponentType,
597 kQTFileTypePicture, &graphicsImporter);
598 QCFType<CGImageRef> cgImage;
599 if (!result)
600 result = ptrGraphicsImportSetDataHandle(graphicsImporter, pic);
601 if (!result)
602 result = ptrGraphicsImportCreateCGImage(graphicsImporter, &cgImage,
603 kGraphicsImportCreateCGImageUsingCurrentSettings);
604 if (!result)
605 ret = QVariant(QPixmap::fromMacCGImageRef(cgImage).toImage());
606 CloseComponent(graphicsImporter);
607 DisposeHandle(pic);
608 return ret;
609}
610
611QList<QByteArray> QMacPasteboardMimePict::convertFromMime(const QString &mime, QVariant variant,
612 QString flav)
613{
614 QList<QByteArray> ret;
615 if (!resolveMimeQuickTimeSymbols())
616 return ret;
617
618 if (!canConvert(mime, flav))
619 return ret;
620 QCFType<CGImageRef> cgimage = qt_mac_createCGImageFromQImage(qvariant_cast<QImage>(variant));
621 Handle pic = NewHandle(0);
622 GraphicsExportComponent graphicsExporter;
623 ComponentResult result = OpenADefaultComponent(GraphicsExporterComponentType,
624 kQTFileTypePicture, &graphicsExporter);
625 if (!result) {
626 unsigned long sizeWritten;
627 result = ptrGraphicsExportSetInputCGImage(graphicsExporter, cgimage);
628 if (!result)
629 result = ptrGraphicsExportSetOutputHandle(graphicsExporter, pic);
630 if (!result)
631 result = ptrGraphicsExportDoExport(graphicsExporter, &sizeWritten);
632
633 CloseComponent(graphicsExporter);
634 }
635
636 int size = GetHandleSize((Handle)pic);
637 // Skip the Picture File header (512 bytes) and feed the raw data
638 QByteArray ar(reinterpret_cast<char *>(*pic + 512), size - 512);
639 ret.append(ar);
640 DisposeHandle(pic);
641 return ret;
642}
643
644
645#endif //Q_WS_MAC32
646
647class QMacPasteboardMimeTiff : public QMacPasteboardMime {
648public:
649 QMacPasteboardMimeTiff() : QMacPasteboardMime(MIME_ALL) { }
650 QString convertorName();
651
652 QString flavorFor(const QString &mime);
653 QString mimeFor(QString flav);
654 bool canConvert(const QString &mime, QString flav);
655 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
656 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
657};
658
659QString QMacPasteboardMimeTiff::convertorName()
660{
661 return QLatin1String("Tiff");
662}
663
664QString QMacPasteboardMimeTiff::flavorFor(const QString &mime)
665{
666 if(mime.startsWith(QLatin1String("application/x-qt-image")))
667 return QLatin1String("public.tiff");
668 return QString();
669}
670
671QString QMacPasteboardMimeTiff::mimeFor(QString flav)
672{
673 if(flav == QLatin1String("public.tiff"))
674 return QLatin1String("application/x-qt-image");
675 return QString();
676}
677
678bool QMacPasteboardMimeTiff::canConvert(const QString &mime, QString flav)
679{
680 return flav == QLatin1String("public.tiff") && mime == QLatin1String("application/x-qt-image");
681}
682
683QVariant QMacPasteboardMimeTiff::convertToMime(const QString &mime, QList<QByteArray> data, QString flav)
684{
685 if(data.count() > 1)
686 qWarning("QMacPasteboardMimeTiff: Cannot handle multiple member data");
687 QVariant ret;
688 if (!canConvert(mime, flav))
689 return ret;
690 const QByteArray &a = data.first();
691 QCFType<CGImageRef> image;
692 QCFType<CFDataRef> tiffData = CFDataCreateWithBytesNoCopy(0,
693 reinterpret_cast<const UInt8 *>(a.constData()),
694 a.size(), kCFAllocatorNull);
695 QCFType<CGImageSourceRef> imageSource = CGImageSourceCreateWithData(tiffData, 0);
696 image = CGImageSourceCreateImageAtIndex(imageSource, 0, 0);
697
698 if (image != 0)
699 ret = QVariant(QPixmap::fromMacCGImageRef(image).toImage());
700 return ret;
701}
702
703QList<QByteArray> QMacPasteboardMimeTiff::convertFromMime(const QString &mime, QVariant variant, QString flav)
704{
705 QList<QByteArray> ret;
706 if (!canConvert(mime, flav))
707 return ret;
708
709 QImage img = qvariant_cast<QImage>(variant);
710 QCFType<CGImageRef> cgimage = qt_mac_createCGImageFromQImage(img);
711#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
712 if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
713 QCFType<CFMutableDataRef> data = CFDataCreateMutable(0, 0);
714 QCFType<CGImageDestinationRef> imageDestination = CGImageDestinationCreateWithData(data, kUTTypeTIFF, 1, 0);
715 if (imageDestination != 0) {
716 CFTypeRef keys[2];
717 QCFType<CFTypeRef> values[2];
718 QCFType<CFDictionaryRef> options;
719 keys[0] = kCGImagePropertyPixelWidth;
720 keys[1] = kCGImagePropertyPixelHeight;
721 int width = img.width();
722 int height = img.height();
723 values[0] = CFNumberCreate(0, kCFNumberIntType, &width);
724 values[1] = CFNumberCreate(0, kCFNumberIntType, &height);
725 options = CFDictionaryCreate(0, reinterpret_cast<const void **>(keys),
726 reinterpret_cast<const void **>(values), 2,
727 &kCFTypeDictionaryKeyCallBacks,
728 &kCFTypeDictionaryValueCallBacks);
729 CGImageDestinationAddImage(imageDestination, cgimage, options);
730 CGImageDestinationFinalize(imageDestination);
731 }
732 QByteArray ar(CFDataGetLength(data), 0);
733 CFDataGetBytes(data,
734 CFRangeMake(0, ar.size()),
735 reinterpret_cast<UInt8 *>(ar.data()));
736 ret.append(ar);
737 } else
738#endif
739 {
740#ifdef Q_WS_MAC32
741 Handle tiff = NewHandle(0);
742 if (resolveMimeQuickTimeSymbols()) {
743 GraphicsExportComponent graphicsExporter;
744 ComponentResult result = OpenADefaultComponent(GraphicsExporterComponentType,
745 kQTFileTypeTIFF, &graphicsExporter);
746 if (!result) {
747 unsigned long sizeWritten;
748 result = ptrGraphicsExportSetInputCGImage(graphicsExporter, cgimage);
749 if (!result)
750 result = ptrGraphicsExportSetOutputHandle(graphicsExporter, tiff);
751 if (!result)
752 result = ptrGraphicsExportDoExport(graphicsExporter, &sizeWritten);
753
754 CloseComponent(graphicsExporter);
755 }
756 }
757 int size = GetHandleSize((Handle)tiff);
758 QByteArray ar(reinterpret_cast<char *>(*tiff), size);
759 ret.append(ar);
760 DisposeHandle(tiff);
761#endif
762 }
763 return ret;
764}
765
766
767class QMacPasteboardMimeFileUri : public QMacPasteboardMime {
768public:
769 QMacPasteboardMimeFileUri() : QMacPasteboardMime(MIME_ALL) { }
770 QString convertorName();
771
772 QString flavorFor(const QString &mime);
773 QString mimeFor(QString flav);
774 bool canConvert(const QString &mime, QString flav);
775 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
776 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
777};
778
779QString QMacPasteboardMimeFileUri::convertorName()
780{
781 return QLatin1String("FileURL");
782}
783
784QString QMacPasteboardMimeFileUri::flavorFor(const QString &mime)
785{
786 if (mime == QLatin1String("text/uri-list"))
787 return QCFString(UTTypeCreatePreferredIdentifierForTag(kUTTagClassOSType, CFSTR("furl"), 0));
788 return QString();
789}
790
791QString QMacPasteboardMimeFileUri::mimeFor(QString flav)
792{
793 if (flav == QCFString(UTTypeCreatePreferredIdentifierForTag(kUTTagClassOSType, CFSTR("furl"), 0)))
794 return QLatin1String("text/uri-list");
795 return QString();
796}
797
798bool QMacPasteboardMimeFileUri::canConvert(const QString &mime, QString flav)
799{
800 return mime == QLatin1String("text/uri-list")
801 && flav == QCFString(UTTypeCreatePreferredIdentifierForTag(kUTTagClassOSType, CFSTR("furl"), 0));
802}
803
804QVariant QMacPasteboardMimeFileUri::convertToMime(const QString &mime, QList<QByteArray> data, QString flav)
805{
806 if(!canConvert(mime, flav))
807 return QVariant();
808 QList<QVariant> ret;
809 for(int i = 0; i < data.size(); ++i) {
810 QUrl url = QUrl::fromEncoded(data.at(i));
811 if (url.host().toLower() == QLatin1String("localhost"))
812 url.setHost(QString());
813 url.setPath(url.path().normalized(QString::NormalizationForm_C));
814 ret.append(url);
815 }
816 return QVariant(ret);
817}
818
819QList<QByteArray> QMacPasteboardMimeFileUri::convertFromMime(const QString &mime, QVariant data, QString flav)
820{
821 QList<QByteArray> ret;
822 if (!canConvert(mime, flav))
823 return ret;
824 QList<QVariant> urls = data.toList();
825 for(int i = 0; i < urls.size(); ++i) {
826 QUrl url = urls.at(i).toUrl();
827 if (url.scheme().isEmpty())
828 url.setScheme(QLatin1String("file"));
829 if (url.scheme().toLower() == QLatin1String("file")) {
830 if (url.host().isEmpty())
831 url.setHost(QLatin1String("localhost"));
832 url.setPath(url.path().normalized(QString::NormalizationForm_D));
833 }
834 ret.append(url.toEncoded());
835 }
836 return ret;
837}
838
839class QMacPasteboardMimeUrl : public QMacPasteboardMime {
840public:
841 QMacPasteboardMimeUrl() : QMacPasteboardMime(MIME_ALL) { }
842 QString convertorName();
843
844 QString flavorFor(const QString &mime);
845 QString mimeFor(QString flav);
846 bool canConvert(const QString &mime, QString flav);
847 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
848 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
849};
850
851QString QMacPasteboardMimeUrl::convertorName()
852{
853 return QLatin1String("URL");
854}
855
856QString QMacPasteboardMimeUrl::flavorFor(const QString &mime)
857{
858 if(mime.startsWith(QLatin1String("text/uri-list")))
859 return QLatin1String("public.url");
860 return QString();
861}
862
863QString QMacPasteboardMimeUrl::mimeFor(QString flav)
864{
865 if(flav == QLatin1String("public.url"))
866 return QLatin1String("text/uri-list");
867 return QString();
868}
869
870bool QMacPasteboardMimeUrl::canConvert(const QString &mime, QString flav)
871{
872 return flav == QLatin1String("public.url")
873 && mime == QLatin1String("text/uri-list");
874}
875
876QVariant QMacPasteboardMimeUrl::convertToMime(const QString &mime, QList<QByteArray> data, QString flav)
877{
878 if(!canConvert(mime, flav))
879 return QVariant();
880
881 QList<QVariant> ret;
882 for (int i=0; i<data.size(); ++i) {
883 QUrl url = QUrl::fromEncoded(data.at(i));
884 if (url.host().toLower() == QLatin1String("localhost"))
885 url.setHost(QString());
886 url.setPath(url.path().normalized(QString::NormalizationForm_C));
887 ret.append(url);
888 }
889 return QVariant(ret);
890}
891
892QList<QByteArray> QMacPasteboardMimeUrl::convertFromMime(const QString &mime, QVariant data, QString flav)
893{
894 QList<QByteArray> ret;
895 if (!canConvert(mime, flav))
896 return ret;
897
898 QList<QVariant> urls = data.toList();
899 for(int i=0; i<urls.size(); ++i) {
900 QUrl url = urls.at(i).toUrl();
901 if (url.scheme().isEmpty())
902 url.setScheme(QLatin1String("file"));
903 if (url.scheme().toLower() == QLatin1String("file")) {
904 if (url.host().isEmpty())
905 url.setHost(QLatin1String("localhost"));
906 url.setPath(url.path().normalized(QString::NormalizationForm_D));
907 }
908 ret.append(url.toEncoded());
909 }
910 return ret;
911}
912
913class QMacPasteboardMimeVCard : public QMacPasteboardMime
914{
915public:
916 QMacPasteboardMimeVCard() : QMacPasteboardMime(MIME_ALL){ }
917 QString convertorName();
918
919 QString flavorFor(const QString &mime);
920 QString mimeFor(QString flav);
921 bool canConvert(const QString &mime, QString flav);
922 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
923 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
924};
925
926QString QMacPasteboardMimeVCard::convertorName()
927{
928 return QString("VCard");
929}
930
931bool QMacPasteboardMimeVCard::canConvert(const QString &mime, QString flav)
932{
933 return mimeFor(flav) == mime;
934}
935
936QString QMacPasteboardMimeVCard::flavorFor(const QString &mime)
937{
938 if(mime.startsWith(QLatin1String("text/plain")))
939 return QLatin1String("public.vcard");
940 return QString();
941}
942
943QString QMacPasteboardMimeVCard::mimeFor(QString flav)
944{
945 if (flav == QLatin1String("public.vcard"))
946 return QLatin1String("text/plain");
947 return QString();
948}
949
950QVariant QMacPasteboardMimeVCard::convertToMime(const QString &mime, QList<QByteArray> data, QString)
951{
952 QByteArray cards;
953 if (mime == QLatin1String("text/plain")) {
954 for (int i=0; i<data.size(); ++i)
955 cards += data[i];
956 }
957 return QVariant(cards);
958}
959
960QList<QByteArray> QMacPasteboardMimeVCard::convertFromMime(const QString &mime, QVariant data, QString)
961{
962 QList<QByteArray> ret;
963 if (mime == QLatin1String("text/plain"))
964 ret.append(data.toString().toUtf8());
965 return ret;
966}
967
968#ifdef QT3_SUPPORT
969class QMacPasteboardMimeQt3Any : public QMacPasteboardMime {
970private:
971 int current_max;
972 QFile library_file;
973 QDateTime mime_registry_loaded;
974 QMap<QString, int> mime_registry;
975 int registerMimeType(const QString &mime);
976 bool loadMimeRegistry();
977
978public:
979 QMacPasteboardMimeQt3Any() : QMacPasteboardMime(MIME_QT3_CONVERTOR) {
980 current_max = 'QT00';
981 }
982 ~QMacPasteboardMimeQt3Any() {
983 }
984 QString convertorName();
985
986 QString flavorFor(const QString &mime);
987 QString mimeFor(QString flav);
988 bool canConvert(const QString &mime, QString flav);
989 QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav);
990 QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav);
991};
992
993static bool qt_mac_openMimeRegistry(bool global, QIODevice::OpenMode mode, QFile &file)
994{
995 QString dir = QLatin1String("/Library/Qt");
996 if(!global)
997 dir.prepend(QDir::homePath());
998 file.setFileName(dir + QLatin1String("/.mime_types"));
999 if(mode != QIODevice::ReadOnly) {
1000 if(!QFile::exists(dir)) {
1001 // Do it with a system call as I don't see much worth in
1002 // doing it with QDir since we have to chmod anyway.
1003 bool success = ::mkdir(dir.toLocal8Bit().constData(), S_IRUSR | S_IWUSR | S_IXUSR) == 0;
1004 if (success)
1005 success = ::chmod(dir.toLocal8Bit().constData(), S_IRUSR | S_IWUSR | S_IXUSR
1006 | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH) == 0;
1007 if (!success)
1008 return false;
1009 }
1010 if (!file.exists()) {
1011 // Create the file and chmod it so that everyone can write to it.
1012 int fd = ::open(file.fileName().toLocal8Bit().constData(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
1013 bool success = fd != -1;
1014 if (success)
1015 success = ::fchmod(fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) == 0;
1016 if (fd != -1)
1017 ::close(fd);
1018 if(!success)
1019 return false;
1020 }
1021 }
1022 return file.open(mode);
1023}
1024
1025static void qt_mac_loadMimeRegistry(QFile &file, QMap<QString, int> &registry, int &max)
1026{
1027 file.reset();
1028 QTextStream stream(&file);
1029 while(!stream.atEnd()) {
1030 QString mime = stream.readLine();
1031 int mactype = stream.readLine().toInt();
1032 if(mactype > max)
1033 max = mactype;
1034 registry.insert(mime, mactype);
1035 }
1036}
1037
1038bool QMacPasteboardMimeQt3Any::loadMimeRegistry()
1039{
1040 if(!library_file.isOpen()) {
1041 if(!qt_mac_openMimeRegistry(true, QIODevice::ReadWrite, library_file)) {
1042 QFile global;
1043 if(qt_mac_openMimeRegistry(true, QIODevice::ReadOnly, global)) {
1044 qt_mac_loadMimeRegistry(global, mime_registry, current_max);
1045 global.close();
1046 }
1047 if(!qt_mac_openMimeRegistry(false, QIODevice::ReadWrite, library_file)) {
1048 qWarning("QMacPasteboardMimeAnyQt3Mime: Failure to open mime resources %s -- %s", library_file.fileName().toLatin1().constData(),
1049 library_file.errorString().toLatin1().constData());
1050 return false;
1051 }
1052 }
1053 }
1054
1055 QFileInfo fi(library_file);
1056 if(!mime_registry_loaded.isNull() && mime_registry_loaded == fi.lastModified())
1057 return true;
1058 mime_registry_loaded = fi.lastModified();
1059 qt_mac_loadMimeRegistry(library_file, mime_registry, current_max);
1060 return true;
1061}
1062
1063int QMacPasteboardMimeQt3Any::registerMimeType(const QString &mime)
1064{
1065 if(!mime_registry.contains(mime)) {
1066 if(!loadMimeRegistry()) {
1067 qWarning("QMacPasteboardMimeAnyQt3Mime: Internal error");
1068 return 0;
1069 }
1070 if(!mime_registry.contains(mime)) {
1071 if(!library_file.isOpen()) {
1072 if(!library_file.open(QIODevice::WriteOnly)) {
1073 qWarning("QMacPasteboardMimeAnyQt3Mime: Failure to open %s -- %s", library_file.fileName().toLatin1().constData(),
1074 library_file.errorString().toLatin1().constData());
1075 return false;
1076 }
1077 }
1078 int ret = ++current_max;
1079 mime_registry_loaded = QFileInfo(library_file).lastModified();
1080 QTextStream stream(&library_file);
1081 stream << mime << endl;
1082 stream << ret << endl;
1083 mime_registry.insert(mime, ret);
1084 library_file.flush(); //flush and set mtime
1085 return ret;
1086 }
1087 }
1088 return mime_registry[mime];
1089}
1090
1091QString QMacPasteboardMimeQt3Any::convertorName()
1092{
1093 return QLatin1String("Qt3-Any-Mime");
1094}
1095
1096QString QMacPasteboardMimeQt3Any::flavorFor(const QString &mime)
1097{
1098 const int os_flav = registerMimeType(mime);
1099 QCFType<CFArrayRef> ids = UTTypeCreateAllIdentifiersForTag(0, kUTTagClassOSType,
1100 QCFString(UTCreateStringForOSType(os_flav)));
1101 if(ids) {
1102 const int type_count = CFArrayGetCount(ids);
1103 if(type_count) {
1104 if(type_count > 1)
1105 qDebug("Can't happen!");
1106 return QCFString::toQString((CFStringRef)CFArrayGetValueAtIndex(ids, 0));
1107 }
1108 }
1109 return QString();
1110}
1111
1112QString QMacPasteboardMimeQt3Any::mimeFor(QString flav)
1113{
1114 loadMimeRegistry();
1115 const int os_flav = UTGetOSTypeFromString(UTTypeCopyPreferredTagWithClass(QCFString(flav), kUTTagClassOSType));
1116 for(QMap<QString, int>::const_iterator it = mime_registry.constBegin();
1117 it != mime_registry.constEnd(); ++it) {
1118 if(it.value() == os_flav)
1119 return QString::fromLatin1(it.key().toLatin1());
1120 }
1121 return QString();
1122}
1123
1124bool QMacPasteboardMimeQt3Any::canConvert(const QString &mime, QString flav)
1125{
1126 loadMimeRegistry();
1127 const int os_flav = UTGetOSTypeFromString(UTTypeCopyPreferredTagWithClass(QCFString(flav), kUTTagClassOSType));
1128 if(mime_registry.contains(mime) && mime_registry[mime] == os_flav)
1129 return true;
1130 return false;
1131}
1132
1133QVariant QMacPasteboardMimeQt3Any::convertToMime(const QString &, QList<QByteArray>, QString)
1134{
1135 qWarning("QMacPasteboardMimeAnyQt3Mime: Cannot write anything!");
1136 return QVariant();
1137}
1138
1139QList<QByteArray> QMacPasteboardMimeQt3Any::convertFromMime(const QString &mime, QVariant data, QString)
1140{
1141 QList<QByteArray> ret;
1142 if (mime == QLatin1String("text/plain")) {
1143 ret.append(data.toString().toUtf8());
1144 } else {
1145 ret.append(data.toByteArray());
1146 }
1147 return ret;
1148}
1149#endif
1150
1151/*!
1152 \internal
1153
1154 This is an internal function.
1155*/
1156void QMacPasteboardMime::initialize()
1157{
1158 if(globalMimeList()->isEmpty()) {
1159 qAddPostRoutine(cleanup_mimes);
1160
1161 //standard types that we wrap
1162 new QMacPasteboardMimeTiff;
1163#ifdef Q_WS_MAC32
1164 // 10.6 does automatic synthesis to and from PICT to standard image types (like TIFF),
1165 // so don't bother doing it ourselves, especially since it's not available in 64-bit.
1166 if (QSysInfo::MacintoshVersion < QSysInfo::MV_10_6)
1167 new QMacPasteboardMimePict;
1168#endif
1169 new QMacPasteboardMimeUnicodeText;
1170 new QMacPasteboardMimePlainText;
1171 new QMacPasteboardMimeHTMLText;
1172 new QMacPasteboardMimeFileUri;
1173 new QMacPasteboardMimeUrl;
1174 new QMacPasteboardMimeTypeName;
1175 new QMacPasteboardMimeVCard;
1176 //make sure our "non-standard" types are always last! --Sam
1177 new QMacPasteboardMimeAny;
1178#ifdef QT3_SUPPORT
1179 new QMacPasteboardMimeQt3Any;
1180#endif
1181 }
1182}
1183
1184/*!
1185 Returns the most-recently created QMacPasteboardMime of type \a t that can convert
1186 between the \a mime and \a flav formats. Returns 0 if no such convertor
1187 exists.
1188*/
1189QMacPasteboardMime*
1190QMacPasteboardMime::convertor(uchar t, const QString &mime, QString flav)
1191{
1192 MimeList *mimes = globalMimeList();
1193 for(MimeList::const_iterator it = mimes->constBegin(); it != mimes->constEnd(); ++it) {
1194#ifdef DEBUG_MIME_MAPS
1195 qDebug("QMacPasteboardMime::convertor: seeing if %s (%d) can convert %s to %d[%c%c%c%c] [%d]",
1196 (*it)->convertorName().toLatin1().constData(),
1197 (*it)->type & t, mime.toLatin1().constData(),
1198 flav, (flav >> 24) & 0xFF, (flav >> 16) & 0xFF, (flav >> 8) & 0xFF, (flav) & 0xFF,
1199 (*it)->canConvert(mime,flav));
1200 for(int i = 0; i < (*it)->countFlavors(); ++i) {
1201 int f = (*it)->flavor(i);
1202 qDebug(" %d) %d[%c%c%c%c] [%s]", i, f,
1203 (f >> 24) & 0xFF, (f >> 16) & 0xFF, (f >> 8) & 0xFF, (f) & 0xFF,
1204 (*it)->convertorName().toLatin1().constData());
1205 }
1206#endif
1207 if(((*it)->type & t) && (*it)->canConvert(mime, flav))
1208 return (*it);
1209 }
1210 return 0;
1211}
1212/*!
1213 Returns a MIME type of type \a t for \a flav, or 0 if none exists.
1214*/
1215QString QMacPasteboardMime::flavorToMime(uchar t, QString flav)
1216{
1217 MimeList *mimes = globalMimeList();
1218 for(MimeList::const_iterator it = mimes->constBegin(); it != mimes->constEnd(); ++it) {
1219#ifdef DEBUG_MIME_MAPS
1220 qDebug("QMacMIme::flavorToMime: attempting %s (%d) for flavor %d[%c%c%c%c] [%s]",
1221 (*it)->convertorName().toLatin1().constData(),
1222 (*it)->type & t, flav, (flav >> 24) & 0xFF, (flav >> 16) & 0xFF, (flav >> 8) & 0xFF, (flav) & 0xFF,
1223 (*it)->mimeFor(flav).toLatin1().constData());
1224
1225#endif
1226 if((*it)->type & t) {
1227 QString mimeType = (*it)->mimeFor(flav);
1228 if(!mimeType.isNull())
1229 return mimeType;
1230 }
1231 }
1232 return QString();
1233}
1234
1235/*!
1236 Returns a list of all currently defined QMacPasteboardMime objects of type \a t.
1237*/
1238QList<QMacPasteboardMime*> QMacPasteboardMime::all(uchar t)
1239{
1240 MimeList ret;
1241 MimeList *mimes = globalMimeList();
1242 for(MimeList::const_iterator it = mimes->constBegin(); it != mimes->constEnd(); ++it) {
1243 if((*it)->type & t)
1244 ret.append((*it));
1245 }
1246 return ret;
1247}
1248
1249
1250/*!
1251 \fn QString QMacPasteboardMime::convertorName()
1252
1253 Returns a name for the convertor.
1254
1255 All subclasses must reimplement this pure virtual function.
1256*/
1257
1258/*!
1259 \fn bool QMacPasteboardMime::canConvert(const QString &mime, QString flav)
1260
1261 Returns true if the convertor can convert (both ways) between
1262 \a mime and \a flav; otherwise returns false.
1263
1264 All subclasses must reimplement this pure virtual function.
1265*/
1266
1267/*!
1268 \fn QString QMacPasteboardMime::mimeFor(QString flav)
1269
1270 Returns the MIME UTI used for Mac flavor \a flav, or 0 if this
1271 convertor does not support \a flav.
1272
1273 All subclasses must reimplement this pure virtual function.
1274*/
1275
1276/*!
1277 \fn QString QMacPasteboardMime::flavorFor(const QString &mime)
1278
1279 Returns the Mac UTI used for MIME type \a mime, or 0 if this
1280 convertor does not support \a mime.
1281
1282 All subclasses must reimplement this pure virtual function.
1283*/
1284
1285/*!
1286 \fn QVariant QMacPasteboardMime::convertToMime(const QString &mime, QList<QByteArray> data, QString flav)
1287
1288 Returns \a data converted from Mac UTI \a flav to MIME type \a
1289 mime.
1290
1291 Note that Mac flavors must all be self-terminating. The input \a
1292 data may contain trailing data.
1293
1294 All subclasses must reimplement this pure virtual function.
1295*/
1296
1297/*!
1298 \fn QList<QByteArray> QMacPasteboardMime::convertFromMime(const QString &mime, QVariant data, QString flav)
1299
1300 Returns \a data converted from MIME type \a mime
1301 to Mac UTI \a flav.
1302
1303 Note that Mac flavors must all be self-terminating. The return
1304 value may contain trailing data.
1305
1306 All subclasses must reimplement this pure virtual function.
1307*/
1308
1309
1310QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.