source: trunk/include/qmime.h@ 97

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

kernel: Created the initial implementation of the Drag'n'Drop support for OS/2 (not fully functiona yet: updating widget contents under the drag pointer will cause screen corruption, setting the drag object's pixmap is not possible). See ticket:22 for more info.
  • Property svn:keywords set to Id
File size: 12.9 KB
Line 
1/****************************************************************************
2** $Id: qmime.h 97 2006-07-06 21:25:56Z 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 Messenger
178 {
179 public:
180 Messenger();
181 virtual ~Messenger();
182 HWND hwnd() const { return w; }
183 virtual MRESULT message( ULONG msg, MPARAM mp1, MPARAM mp2 ) = 0;
184 private:
185 HWND w;
186 static MRESULT EXPENTRY windowProc( HWND, ULONG, MPARAM, MPARAM );
187 };
188
189 class DragWorker
190 {
191 public:
192 DragWorker() : src( NULL ) {}
193 virtual ~DragWorker() {}
194
195 const QMimeSource *source() const { return src; }
196
197 virtual void init() {}
198 // methods always implemented
199 virtual bool cleanup( bool isCancelled ) = 0;
200 virtual bool isExclusive() const = 0;
201 virtual ULONG itemCount() const = 0;
202 virtual HWND hwnd() const = 0;
203 // methods implemented if isExclusive() == TRUE and itemCount() == 0
204 virtual DRAGINFO *createDragInfo( const char *name, USHORT supportedOps )
205 { return NULL; }
206 // methods implemented if itemCount() >= 0
207 virtual QCString composeFormatString() { return QCString(); }
208 virtual bool prepare( const char *drm, const char *drf, DRAGITEM *item,
209 ULONG itemIndex ) { return FALSE; }
210 virtual void defaultFileType( const char *&type, const char *&ext ) {};
211
212 private:
213 const QMimeSource *src;
214 friend class QPMCoopDragWorker;
215 friend class QDragManager;
216 };
217
218 class DefaultDragWorker : public DragWorker, public Messenger
219 {
220 private:
221 DefaultDragWorker( bool exclusive );
222 public:
223 virtual ~DefaultDragWorker();
224
225 // DragpWorker interface
226 bool cleanup( bool isCancelled );
227 bool isExclusive() const;
228 ULONG itemCount() const;
229 HWND hwnd() const { return Messenger::hwnd(); }
230 QCString composeFormatString();
231 bool prepare( const char *drm, const char *drf, DRAGITEM *item,
232 ULONG itemIndex );
233 void defaultFileType( const char *&type, const char *&ext );
234
235 // Messenger interface
236 MRESULT message( ULONG msg, MPARAM mp1, MPARAM mp2 );
237
238 class Provider
239 {
240 public:
241 virtual const char *format( const char *drf ) const = 0;
242 virtual bool provide( const char *drf, const QByteArray &allData,
243 ULONG itemIndex, QByteArray &itemData ) = 0;
244 virtual void fileType( const char *drf, const char *&type,
245 const char *&ext ) {};
246 };
247
248 bool addProvider( const char *drf, Provider *provider,
249 ULONG itemCount = 1 );
250
251 static bool canRender( const char *drm );
252
253 private:
254 struct Data;
255 Data *d;
256 friend class QPMMime;
257 };
258
259 class DropWorker
260 {
261 public:
262 DropWorker() : nfo( NULL ) {}
263 virtual ~DropWorker() {}
264
265 DRAGINFO *info() const { return nfo; }
266
267 virtual void init() {}
268 virtual void cleanup( bool isAccepted, bool isActAccepted ) {}
269 virtual bool isExclusive() const = 0;
270 virtual bool provides( const char *format ) const = 0;
271 virtual int formatCount() const = 0;
272 virtual const char *format( int fn ) const = 0;
273 virtual QByteArray encodedData( const char *format ) const = 0;
274
275 private:
276 DRAGINFO *nfo;
277 friend class QPMDragData;
278 };
279
280 class DefaultDropWorker : public DropWorker, public Messenger
281 {
282 private:
283 DefaultDropWorker();
284 public:
285 virtual ~DefaultDropWorker();
286
287 // DropWorker interface
288 void cleanup( bool isAccepted, bool isActAccepted );
289 bool isExclusive() const;
290 bool provides( const char *format ) const;
291 int formatCount() const;
292 const char *format( int fn ) const;
293 QByteArray encodedData( const char *format ) const;
294
295 // Messenger interface
296 MRESULT message( ULONG msg, MPARAM mp1, MPARAM mp2 );
297
298 class Provider
299 {
300 public:
301 virtual const char *drf( const char *format ) const = 0;
302 virtual bool provide( const char *format, ULONG itemIndex,
303 const QByteArray &itemData,
304 QByteArray &allData ) = 0;
305 };
306
307 bool addProvider( const char *format, Provider *provider );
308 bool addExclusiveProvider( const char *format, Provider *provider );
309
310 static bool canRender( DRAGITEM *item, const char *drf );
311 static bool getSupportedRMFs( DRAGITEM *item, QPtrList<QStrList> &list );
312
313 private:
314 struct Data;
315 Data *d;
316 friend class QPMMime;
317 };
318
319#endif // !QT_NO_DRAGANDDROP
320
321 enum { CFI_Storage = CFI_POINTER & CFI_HANDLE };
322
323 QPMMime();
324 virtual ~QPMMime();
325
326 static void initialize();
327
328 static QPtrList<QPMMime> all();
329 static QPMMime* convertor( const char* mime, ulong cf );
330 static const char* cfToMime( ulong cf );
331
332#if !defined(QT_NO_DRAGANDDROP)
333
334 static QCString queryHSTR( HSTR hstr );
335 static QCString querySourceNameFull( DRAGITEM *item );
336 static bool canTargetRenderAsOS2File( DRAGITEM *item, QCString *fullName = NULL );
337 static bool parseRMFs( HSTR rmfs, QPtrList<QStrList> &list );
338 static bool parseRMF( HSTR rmf, QCString &mechanism, QCString &format );
339
340 static DefaultDragWorker *defaultCoopDragWorker();
341 static DefaultDragWorker *defaultExclDragWorker();
342 static DefaultDropWorker *defaultDropWorker();
343
344#endif // !QT_NO_DRAGANDDROP
345
346 // Clipboard format convertor interface
347
348 virtual const char* convertorName() = 0;
349 virtual int countCf() = 0;
350 virtual ulong cf( int index ) = 0;
351 virtual ulong flFor( ulong cf ) = 0;
352 virtual ulong cfFor( const char* ) = 0;
353 virtual const char* mimeFor( ulong cf ) = 0;
354 virtual bool canConvert( const char* mime, ulong cf ) = 0;
355 virtual QByteArray convertToMime( QByteArray data, const char *mime, ulong cf ) = 0;
356 virtual QByteArray convertFromMime( QByteArray data, const char *mime, ulong cf ) = 0;
357
358#if !defined(QT_NO_DRAGANDDROP)
359
360 // Direct Manipulation (DND) convertor interface
361
362 virtual DragWorker *dragWorkerFor( const char *mime, QMimeSource *src ) { return 0; }
363 virtual DropWorker *dropWorkerFor( DRAGINFO *info ) { return 0; }
364
365#endif // !QT_NO_DRAGANDDROP
366};
367
368#endif // Q_WS_PM
369
370#if defined(Q_WS_MAC)
371
372#ifndef QT_H
373#include "qptrlist.h" // down here for GCC 2.7.* compatibility
374#endif // QT_H
375
376/*
377 Encapsulation of conversion between MIME and Mac flavor.
378 Not need on X11, as the underlying protocol uses the MIME standard
379 directly.
380*/
381
382class Q_EXPORT QMacMime {
383 char type;
384public:
385 enum QMacMimeType { MIME_DND=0x01, MIME_CLIP=0x02, MIME_QT_CONVERTOR=0x04, MIME_ALL=MIME_DND|MIME_CLIP };
386 QMacMime(char);
387 virtual ~QMacMime();
388
389 static void initialize();
390
391 static QPtrList<QMacMime> all(QMacMimeType);
392 static QMacMime* convertor(QMacMimeType, const char* mime, int flav);
393 static const char* flavorToMime(QMacMimeType, int flav);
394
395 virtual const char* convertorName()=0;
396 virtual int countFlavors()=0;
397 virtual int flavor(int index)=0;
398 virtual bool canConvert(const char* mime, int flav)=0;
399 virtual const char* mimeFor(int flav)=0;
400 virtual int flavorFor(const char*)=0;
401 virtual QByteArray convertToMime(QValueList<QByteArray> data, const char* mime, int flav)=0;
402 virtual QValueList<QByteArray> convertFromMime(QByteArray data, const char* mime, int flav)=0;
403};
404
405#endif // Q_WS_MAC
406
407#endif // QT_NO_MIME
408
409#endif // QMIME_H
Note: See TracBrowser for help on using the repository browser.