source: trunk/include/qmime.h@ 203

Last change on this file since 203 was 114, checked in by dmik, 19 years ago

Kernel: Updated QPMMime to use QPMObjectWindow instead of its own QPMMime::Messenger.
  • Property svn:keywords set to Id
File size: 12.6 KB
Line 
1/****************************************************************************
2** $Id: qmime.h 114 2006-08-10 17:56:11Z dmik $
3**
4** Definition of mime classes
5**
6** Created : 981204
7**
8** Copyright (C) 1998-2000 Trolltech AS. All rights reserved.
9**
10** This file is part of the kernel module of the Qt GUI Toolkit.
11**
12** This file may be distributed under the terms of the Q Public License
13** as defined by Trolltech AS of Norway and appearing in the file
14** LICENSE.QPL included in the packaging of this file.
15**
16** This file may be distributed and/or modified under the terms of the
17** GNU General Public License version 2 as published by the Free Software
18** Foundation and appearing in the file LICENSE.GPL included in the
19** packaging of this file.
20**
21** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
22** licenses may use this file in accordance with the Qt Commercial License
23** Agreement provided with the Software.
24**
25** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
26** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
27**
28** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
29** information about Qt Commercial License Agreements.
30** See http://www.trolltech.com/qpl/ for QPL licensing information.
31** See http://www.trolltech.com/gpl/ for GPL licensing information.
32**
33** Contact info@trolltech.com if any conditions of this licensing are
34** not clear to you.
35**
36**********************************************************************/
37
38#ifndef QMIME_H
39#define QMIME_H
40
41#ifndef QT_H
42#include "qwindowdefs.h"
43#include "qmap.h"
44#endif // QT_H
45
46#ifndef QT_NO_MIME
47
48class QImageDrag;
49class QTextDrag;
50
51class Q_EXPORT QMimeSource
52{
53 friend class QClipboardData;
54
55public:
56 QMimeSource();
57 virtual ~QMimeSource();
58 virtual const char* format( int n = 0 ) const = 0;
59 virtual bool provides( const char* ) const;
60 virtual QByteArray encodedData( const char* ) const = 0;
61 int serialNumber() const;
62
63private:
64 int ser_no;
65 enum { NoCache, Text, Graphics } cacheType;
66 union
67 {
68 struct
69 {
70 QString *str;
71 QCString *subtype;
72 } txt;
73 struct
74 {
75 QImage *img;
76 QPixmap *pix;
77 } gfx;
78 } cache;
79 void clearCache();
80
81 // friends for caching
82 friend class QImageDrag;
83 friend class QTextDrag;
84
85};
86
87inline int QMimeSource::serialNumber() const
88{ return ser_no; }
89
90class QStringList;
91class QMimeSourceFactoryData;
92
93class Q_EXPORT QMimeSourceFactory {
94public:
95 QMimeSourceFactory();
96 virtual ~QMimeSourceFactory();
97
98 static QMimeSourceFactory* defaultFactory();
99 static void setDefaultFactory( QMimeSourceFactory* );
100 static QMimeSourceFactory* takeDefaultFactory();
101 static void addFactory( QMimeSourceFactory *f );
102 static void removeFactory( QMimeSourceFactory *f );
103
104 virtual const QMimeSource* data(const QString& abs_name) const;
105 virtual QString makeAbsolute(const QString& abs_or_rel_name, const QString& context) const;
106 const QMimeSource* data(const QString& abs_or_rel_name, const QString& context) const;
107
108 virtual void setText( const QString& abs_name, const QString& text );
109 virtual void setImage( const QString& abs_name, const QImage& im );
110 virtual void setPixmap( const QString& abs_name, const QPixmap& pm );
111 virtual void setData( const QString& abs_name, QMimeSource* data );
112 virtual void setFilePath( const QStringList& );
113 virtual QStringList filePath() const;
114 void addFilePath( const QString& );
115 virtual void setExtensionType( const QString& ext, const char* mimetype );
116
117private:
118 QMimeSource *dataInternal(const QString& abs_name, const QMap<QString, QString> &extensions ) const;
119 QMimeSourceFactoryData* d;
120};
121
122#if defined(Q_WS_WIN)
123
124#ifndef QT_H
125#include "qptrlist.h" // down here for GCC 2.7.* compatibility
126#endif // QT_H
127
128/*
129 Encapsulation of conversion between MIME and Windows CLIPFORMAT.
130 Not need on X11, as the underlying protocol uses the MIME standard
131 directly.
132*/
133
134class Q_EXPORT QWindowsMime {
135public:
136 QWindowsMime();
137 virtual ~QWindowsMime();
138
139 static void initialize();
140
141 static QPtrList<QWindowsMime> all();
142 static QWindowsMime* convertor( const char* mime, int cf );
143 static const char* cfToMime(int cf);
144
145 static int registerMimeType(const char *mime);
146
147 virtual const char* convertorName()=0;
148 virtual int countCf()=0;
149 virtual int cf(int index)=0;
150 virtual bool canConvert( const char* mime, int cf )=0;
151 virtual const char* mimeFor(int cf)=0;
152 virtual int cfFor(const char* )=0;
153 virtual QByteArray convertToMime( QByteArray data, const char* mime, int cf )=0;
154 virtual QByteArray convertFromMime( QByteArray data, const char* mime, int cf )=0;
155};
156
157#endif // Q_WS_WIN
158
159#if defined(Q_WS_PM)
160
161#ifndef QT_H
162#include "qptrlist.h"
163#include "qstrlist.h"
164#endif // QT_H
165
166/*
167 Encapsulation of conversion between MIME and OS/2 PM clipboard formats
168 and between MIME and Direct Manipulation (DND) mechanisms and formats.
169*/
170
171class Q_EXPORT QPMMime
172{
173public:
174
175#if !defined(QT_NO_DRAGANDDROP)
176
177 class DragWorker
178 {
179 public:
180 DragWorker() : src( NULL ) {}
181 virtual ~DragWorker() {}
182
183 const QMimeSource *source() const { return src; }
184
185 virtual void init() {}
186 // methods always implemented
187 virtual bool cleanup( bool isCancelled ) = 0;
188 virtual bool isExclusive() const = 0;
189 virtual ULONG itemCount() const = 0;
190 virtual HWND hwnd() const = 0;
191 // methods implemented if isExclusive() == TRUE and itemCount() == 0
192 virtual DRAGINFO *createDragInfo( const char *name, USHORT supportedOps )
193 { return NULL; }
194 // methods implemented if itemCount() >= 0
195 virtual QCString composeFormatString() { return QCString(); }
196 virtual bool prepare( const char *drm, const char *drf, DRAGITEM *item,
197 ULONG itemIndex ) { return FALSE; }
198 virtual void defaultFileType( const char *&type, const char *&ext ) {};
199
200 private:
201 const QMimeSource *src;
202 friend class QPMCoopDragWorker;
203 friend class QDragManager;
204 };
205
206 class DefaultDragWorker : public DragWorker, public QPMObjectWindow
207 {
208 private:
209 DefaultDragWorker( bool exclusive );
210 public:
211 virtual ~DefaultDragWorker();
212
213 // DragpWorker interface
214 bool cleanup( bool isCancelled );
215 bool isExclusive() const;
216 ULONG itemCount() const;
217 HWND hwnd() const { return QPMObjectWindow::hwnd(); }
218 QCString composeFormatString();
219 bool prepare( const char *drm, const char *drf, DRAGITEM *item,
220 ULONG itemIndex );
221 void defaultFileType( const char *&type, const char *&ext );
222
223 // QPMObjectWindow interface
224 MRESULT message( ULONG msg, MPARAM mp1, MPARAM mp2 );
225
226 class Provider
227 {
228 public:
229 virtual const char *format( const char *drf ) const = 0;
230 virtual bool provide( const char *drf, const QByteArray &allData,
231 ULONG itemIndex, QByteArray &itemData ) = 0;
232 virtual void fileType( const char *drf, const char *&type,
233 const char *&ext ) {};
234 };
235
236 bool addProvider( const char *drf, Provider *provider,
237 ULONG itemCount = 1 );
238
239 static bool canRender( const char *drm );
240
241 private:
242 struct Data;
243 Data *d;
244 friend class QPMMime;
245 };
246
247 class DropWorker
248 {
249 public:
250 DropWorker() : nfo( NULL ) {}
251 virtual ~DropWorker() {}
252
253 DRAGINFO *info() const { return nfo; }
254
255 virtual void init() {}
256 virtual void cleanup( bool isAccepted, bool isActAccepted ) {}
257 virtual bool isExclusive() const = 0;
258 virtual bool provides( const char *format ) const = 0;
259 virtual int formatCount() const = 0;
260 virtual const char *format( int fn ) const = 0;
261 virtual QByteArray encodedData( const char *format ) const = 0;
262
263 private:
264 DRAGINFO *nfo;
265 friend class QPMDragData;
266 };
267
268 class DefaultDropWorker : public DropWorker, public QPMObjectWindow
269 {
270 private:
271 DefaultDropWorker();
272 public:
273 virtual ~DefaultDropWorker();
274
275 // DropWorker interface
276 void cleanup( bool isAccepted, bool isActAccepted );
277 bool isExclusive() const;
278 bool provides( const char *format ) const;
279 int formatCount() const;
280 const char *format( int fn ) const;
281 QByteArray encodedData( const char *format ) const;
282
283 // QPMObjectWindow interface
284 MRESULT message( ULONG msg, MPARAM mp1, MPARAM mp2 );
285
286 class Provider
287 {
288 public:
289 virtual const char *drf( const char *format ) const = 0;
290 virtual bool provide( const char *format, ULONG itemIndex,
291 const QByteArray &itemData,
292 QByteArray &allData ) = 0;
293 };
294
295 bool addProvider( const char *format, Provider *provider );
296 bool addExclusiveProvider( const char *format, Provider *provider );
297
298 static bool canRender( DRAGITEM *item, const char *drf );
299 static bool getSupportedRMFs( DRAGITEM *item, QPtrList<QStrList> &list );
300
301 private:
302 struct Data;
303 Data *d;
304 friend class QPMMime;
305 };
306
307#endif // !QT_NO_DRAGANDDROP
308
309 enum { CFI_Storage = CFI_POINTER & CFI_HANDLE };
310
311 QPMMime();
312 virtual ~QPMMime();
313
314 static void initialize();
315
316 static QPtrList<QPMMime> all();
317 static QPMMime* convertor( const char* mime, ulong cf );
318 static const char* cfToMime( ulong cf );
319
320#if !defined(QT_NO_DRAGANDDROP)
321
322 static QCString queryHSTR( HSTR hstr );
323 static QCString querySourceNameFull( DRAGITEM *item );
324 static bool canTargetRenderAsOS2File( DRAGITEM *item, QCString *fullName = NULL );
325 static bool parseRMFs( HSTR rmfs, QPtrList<QStrList> &list );
326 static bool parseRMF( HSTR rmf, QCString &mechanism, QCString &format );
327
328 static DefaultDragWorker *defaultCoopDragWorker();
329 static DefaultDragWorker *defaultExclDragWorker();
330 static DefaultDropWorker *defaultDropWorker();
331
332#endif // !QT_NO_DRAGANDDROP
333
334 // Clipboard format convertor interface
335
336 virtual const char* convertorName() = 0;
337 virtual int countCf() = 0;
338 virtual ulong cf( int index ) = 0;
339 virtual ulong flFor( ulong cf ) = 0;
340 virtual ulong cfFor( const char* ) = 0;
341 virtual const char* mimeFor( ulong cf ) = 0;
342 virtual bool canConvert( const char* mime, ulong cf ) = 0;
343 virtual QByteArray convertToMime( QByteArray data, const char *mime, ulong cf ) = 0;
344 virtual QByteArray convertFromMime( QByteArray data, const char *mime, ulong cf ) = 0;
345
346#if !defined(QT_NO_DRAGANDDROP)
347
348 // Direct Manipulation (DND) convertor interface
349
350 virtual DragWorker *dragWorkerFor( const char *mime, QMimeSource *src ) { return 0; }
351 virtual DropWorker *dropWorkerFor( DRAGINFO *info ) { return 0; }
352
353#endif // !QT_NO_DRAGANDDROP
354};
355
356#endif // Q_WS_PM
357
358#if defined(Q_WS_MAC)
359
360#ifndef QT_H
361#include "qptrlist.h" // down here for GCC 2.7.* compatibility
362#endif // QT_H
363
364/*
365 Encapsulation of conversion between MIME and Mac flavor.
366 Not need on X11, as the underlying protocol uses the MIME standard
367 directly.
368*/
369
370class Q_EXPORT QMacMime {
371 char type;
372public:
373 enum QMacMimeType { MIME_DND=0x01, MIME_CLIP=0x02, MIME_QT_CONVERTOR=0x04, MIME_ALL=MIME_DND|MIME_CLIP };
374 QMacMime(char);
375 virtual ~QMacMime();
376
377 static void initialize();
378
379 static QPtrList<QMacMime> all(QMacMimeType);
380 static QMacMime* convertor(QMacMimeType, const char* mime, int flav);
381 static const char* flavorToMime(QMacMimeType, int flav);
382
383 virtual const char* convertorName()=0;
384 virtual int countFlavors()=0;
385 virtual int flavor(int index)=0;
386 virtual bool canConvert(const char* mime, int flav)=0;
387 virtual const char* mimeFor(int flav)=0;
388 virtual int flavorFor(const char*)=0;
389 virtual QByteArray convertToMime(QValueList<QByteArray> data, const char* mime, int flav)=0;
390 virtual QValueList<QByteArray> convertFromMime(QByteArray data, const char* mime, int flav)=0;
391};
392
393#endif // Q_WS_MAC
394
395#endif // QT_NO_MIME
396
397#endif // QMIME_H
Note: See TracBrowser for help on using the repository browser.