/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/include/wx/dataobj.h
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/include/wx/dataobj.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 10 - (show annotations) (download)
Mon Sep 6 11:40:06 2010 UTC (9 years, 5 months ago) by william
File MIME type: text/plain
File size: 21087 byte(s)
exported r3113 from ./upstream/trunk
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: wx/dataobj.h
3 // Purpose: common data object classes
4 // Author: Vadim Zeitlin, Robert Roebling
5 // Modified by:
6 // Created: 26.05.99
7 // RCS-ID: $Id: dataobj.h 40772 2006-08-23 13:38:45Z VZ $
8 // Copyright: (c) wxWidgets Team
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_DATAOBJ_H_BASE_
13 #define _WX_DATAOBJ_H_BASE_
14
15 // ----------------------------------------------------------------------------
16 // headers
17 // ----------------------------------------------------------------------------
18 #include "wx/defs.h"
19
20 #if wxUSE_DATAOBJ
21
22 #include "wx/string.h"
23 #include "wx/bitmap.h"
24 #include "wx/list.h"
25 #include "wx/arrstr.h"
26
27 // ============================================================================
28 /*
29 Generic data transfer related classes. The class hierarchy is as follows:
30
31 - wxDataObject-
32 / \
33 / \
34 wxDataObjectSimple wxDataObjectComposite
35 / | \
36 / | \
37 wxTextDataObject | wxBitmapDataObject
38 |
39 wxCustomDataObject
40
41 */
42 // ============================================================================
43
44 // ----------------------------------------------------------------------------
45 // wxDataFormat class is declared in platform-specific headers: it represents
46 // a format for data which may be either one of the standard ones (text,
47 // bitmap, ...) or a custom one which is then identified by a unique string.
48 // ----------------------------------------------------------------------------
49
50 /* the class interface looks like this (pseudo code):
51
52 class wxDataFormat
53 {
54 public:
55 typedef <integral type> NativeFormat;
56
57 wxDataFormat(NativeFormat format = wxDF_INVALID);
58 wxDataFormat(const wxChar *format);
59
60 wxDataFormat& operator=(NativeFormat format);
61 wxDataFormat& operator=(const wxDataFormat& format);
62
63 bool operator==(NativeFormat format) const;
64 bool operator!=(NativeFormat format) const;
65
66 void SetType(NativeFormat format);
67 NativeFormat GetType() const;
68
69 wxString GetId() const;
70 void SetId(const wxChar *format);
71 };
72
73 */
74
75 #if defined(__WXMSW__)
76 #include "wx/msw/ole/dataform.h"
77 #elif defined(__WXMOTIF__)
78 #include "wx/motif/dataform.h"
79 #elif defined(__WXGTK20__)
80 #include "wx/gtk/dataform.h"
81 #elif defined(__WXGTK__)
82 #include "wx/gtk1/dataform.h"
83 #elif defined(__WXX11__)
84 #include "wx/x11/dataform.h"
85 #elif defined(__WXMAC__)
86 #include "wx/mac/dataform.h"
87 #elif defined(__WXCOCOA__)
88 #include "wx/cocoa/dataform.h"
89 #elif defined(__WXPM__)
90 #include "wx/os2/dataform.h"
91 #endif
92
93 // the value for default argument to some functions (corresponds to
94 // wxDF_INVALID)
95 extern WXDLLEXPORT const wxDataFormat& wxFormatInvalid;
96
97 // ----------------------------------------------------------------------------
98 // wxDataObject represents a piece of data which knows which formats it
99 // supports and knows how to render itself in each of them - GetDataHere(),
100 // and how to restore data from the buffer (SetData()).
101 //
102 // Although this class may be used directly (i.e. custom classes may be
103 // derived from it), in many cases it might be simpler to use either
104 // wxDataObjectSimple or wxDataObjectComposite classes.
105 //
106 // A data object may be "read only", i.e. support only GetData() functions or
107 // "read-write", i.e. support both GetData() and SetData() (in principle, it
108 // might be "write only" too, but this is rare). Moreover, it doesn't have to
109 // support the same formats in Get() and Set() directions: for example, a data
110 // object containing JPEG image might accept BMPs in GetData() because JPEG
111 // image may be easily transformed into BMP but not in SetData(). Accordingly,
112 // all methods dealing with formats take an additional "direction" argument
113 // which is either SET or GET and which tells the function if the format needs
114 // to be supported by SetData() or GetDataHere().
115 // ----------------------------------------------------------------------------
116
117 class WXDLLEXPORT wxDataObjectBase
118 {
119 public:
120 enum Direction
121 {
122 Get = 0x01, // format is supported by GetDataHere()
123 Set = 0x02, // format is supported by SetData()
124 Both = 0x03 // format is supported by both (unused currently)
125 };
126
127 // this class is polymorphic, hence it needs a virtual dtor
128 virtual ~wxDataObjectBase();
129
130 // get the best suited format for rendering our data
131 virtual wxDataFormat GetPreferredFormat(Direction dir = Get) const = 0;
132
133 // get the number of formats we support
134 virtual size_t GetFormatCount(Direction dir = Get) const = 0;
135
136 // return all formats in the provided array (of size GetFormatCount())
137 virtual void GetAllFormats(wxDataFormat *formats,
138 Direction dir = Get) const = 0;
139
140 // get the (total) size of data for the given format
141 virtual size_t GetDataSize(const wxDataFormat& format) const = 0;
142
143 // copy raw data (in the specified format) to the provided buffer, return
144 // true if data copied successfully, false otherwise
145 virtual bool GetDataHere(const wxDataFormat& format, void *buf) const = 0;
146
147 // get data from the buffer of specified length (in the given format),
148 // return true if the data was read successfully, false otherwise
149 virtual bool SetData(const wxDataFormat& WXUNUSED(format),
150 size_t WXUNUSED(len), const void * WXUNUSED(buf))
151 {
152 return false;
153 }
154
155 // returns true if this format is supported
156 bool IsSupported(const wxDataFormat& format, Direction dir = Get) const;
157 };
158
159 // ----------------------------------------------------------------------------
160 // include the platform-specific declarations of wxDataObject
161 // ----------------------------------------------------------------------------
162
163 #if defined(__WXMSW__)
164 #include "wx/msw/ole/dataobj.h"
165 #elif defined(__WXMOTIF__)
166 #include "wx/motif/dataobj.h"
167 #elif defined(__WXX11__)
168 #include "wx/x11/dataobj.h"
169 #elif defined(__WXGTK20__)
170 #include "wx/gtk/dataobj.h"
171 #elif defined(__WXGTK__)
172 #include "wx/gtk1/dataobj.h"
173 #elif defined(__WXMAC__)
174 #include "wx/mac/dataobj.h"
175 #elif defined(__WXCOCOA__)
176 #include "wx/cocoa/dataobj.h"
177 #elif defined(__WXPM__)
178 #include "wx/os2/dataobj.h"
179 #endif
180
181 // ----------------------------------------------------------------------------
182 // wxDataObjectSimple is a wxDataObject which only supports one format (in
183 // both Get and Set directions, but you may return false from GetDataHere() or
184 // SetData() if one of them is not supported). This is the simplest possible
185 // wxDataObject implementation.
186 //
187 // This is still an "abstract base class" (although it doesn't have any pure
188 // virtual functions), to use it you should derive from it and implement
189 // GetDataSize(), GetDataHere() and SetData() functions because the base class
190 // versions don't do anything - they just return "not implemented".
191 //
192 // This class should be used when you provide data in only one format (no
193 // conversion to/from other formats), either a standard or a custom one.
194 // Otherwise, you should use wxDataObjectComposite or wxDataObject directly.
195 // ----------------------------------------------------------------------------
196
197 class WXDLLEXPORT wxDataObjectSimple : public wxDataObject
198 {
199 public:
200 // ctor takes the format we support, but it can also be set later with
201 // SetFormat()
202 wxDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
203 : m_format(format)
204 {
205 }
206
207 // get/set the format we support
208 const wxDataFormat& GetFormat() const { return m_format; }
209 void SetFormat(const wxDataFormat& format) { m_format = format; }
210
211 // virtual functions to override in derived class (the base class versions
212 // just return "not implemented")
213 // -----------------------------------------------------------------------
214
215 // get the size of our data
216 virtual size_t GetDataSize() const
217 { return 0; }
218
219 // copy our data to the buffer
220 virtual bool GetDataHere(void *WXUNUSED(buf)) const
221 { return false; }
222
223 // copy data from buffer to our data
224 virtual bool SetData(size_t WXUNUSED(len), const void *WXUNUSED(buf))
225 { return false; }
226
227 // implement base class pure virtuals
228 // ----------------------------------
229 virtual wxDataFormat GetPreferredFormat(wxDataObjectBase::Direction WXUNUSED(dir) = Get) const
230 { return m_format; }
231 virtual size_t GetFormatCount(wxDataObjectBase::Direction WXUNUSED(dir) = Get) const
232 { return 1; }
233 virtual void GetAllFormats(wxDataFormat *formats,
234 wxDataObjectBase::Direction WXUNUSED(dir) = Get) const
235 { *formats = m_format; }
236 virtual size_t GetDataSize(const wxDataFormat& WXUNUSED(format)) const
237 { return GetDataSize(); }
238 virtual bool GetDataHere(const wxDataFormat& WXUNUSED(format),
239 void *buf) const
240 { return GetDataHere(buf); }
241 virtual bool SetData(const wxDataFormat& WXUNUSED(format),
242 size_t len, const void *buf)
243 { return SetData(len, buf); }
244
245 private:
246 // the one and only format we support
247 wxDataFormat m_format;
248
249 DECLARE_NO_COPY_CLASS(wxDataObjectSimple)
250 };
251
252 // ----------------------------------------------------------------------------
253 // wxDataObjectComposite is the simplest way to implement wxDataObject
254 // supporting multiple formats. It contains several wxDataObjectSimple and
255 // supports all formats supported by any of them.
256 //
257 // This class shouldn't be (normally) derived from, but may be used directly.
258 // If you need more flexibility than what it provides, you should probably use
259 // wxDataObject directly.
260 // ----------------------------------------------------------------------------
261
262 WX_DECLARE_EXPORTED_LIST(wxDataObjectSimple, wxSimpleDataObjectList);
263
264 class WXDLLEXPORT wxDataObjectComposite : public wxDataObject
265 {
266 public:
267 // ctor
268 wxDataObjectComposite();
269 virtual ~wxDataObjectComposite();
270
271 // add data object (it will be deleted by wxDataObjectComposite, hence it
272 // must be allocated on the heap) whose format will become the preferred
273 // one if preferred == true
274 void Add(wxDataObjectSimple *dataObject, bool preferred = false);
275
276 // Report the format passed to the SetData method. This should be the
277 // format of the data object within the composite that recieved data from
278 // the clipboard or the DnD operation. You can use this method to find
279 // out what kind of data object was recieved.
280 wxDataFormat GetReceivedFormat() const;
281
282 // implement base class pure virtuals
283 // ----------------------------------
284 virtual wxDataFormat GetPreferredFormat(wxDataObjectBase::Direction dir = Get) const;
285 virtual size_t GetFormatCount(wxDataObjectBase::Direction dir = Get) const;
286 virtual void GetAllFormats(wxDataFormat *formats, wxDataObjectBase::Direction dir = Get) const;
287 virtual size_t GetDataSize(const wxDataFormat& format) const;
288 virtual bool GetDataHere(const wxDataFormat& format, void *buf) const;
289 virtual bool SetData(const wxDataFormat& format, size_t len, const void *buf);
290 #if defined(__WXMSW__)
291 virtual const void* GetSizeFromBuffer( const void* buffer, size_t* size,
292 const wxDataFormat& format );
293 virtual void* SetSizeInBuffer( void* buffer, size_t size,
294 const wxDataFormat& format );
295 virtual size_t GetBufferOffset( const wxDataFormat& format );
296 #endif
297
298 protected:
299 // returns the pointer to the object which supports this format or NULL
300 wxDataObjectSimple *GetObject(const wxDataFormat& format) const;
301
302 private:
303 // the list of all (simple) data objects whose formats we support
304 wxSimpleDataObjectList m_dataObjects;
305
306 // the index of the preferred one (0 initially, so by default the first
307 // one is the preferred)
308 size_t m_preferred;
309
310 wxDataFormat m_receivedFormat;
311
312 DECLARE_NO_COPY_CLASS(wxDataObjectComposite)
313 };
314
315 // ============================================================================
316 // Standard implementations of wxDataObjectSimple which can be used directly
317 // (i.e. without having to derive from them) for standard data type transfers.
318 //
319 // Note that although all of them can work with provided data, you can also
320 // override their virtual GetXXX() functions to only provide data on demand.
321 // ============================================================================
322
323 // ----------------------------------------------------------------------------
324 // wxTextDataObject contains text data
325 // ----------------------------------------------------------------------------
326
327 class WXDLLEXPORT wxTextDataObject : public wxDataObjectSimple
328 {
329 public:
330 // ctor: you can specify the text here or in SetText(), or override
331 // GetText()
332 wxTextDataObject(const wxString& text = wxEmptyString)
333 : wxDataObjectSimple(
334 #if wxUSE_UNICODE
335 wxDF_UNICODETEXT
336 #else
337 wxDF_TEXT
338 #endif
339 ),
340 m_text(text)
341 {
342 }
343
344 // virtual functions which you may override if you want to provide text on
345 // demand only - otherwise, the trivial default versions will be used
346 virtual size_t GetTextLength() const { return m_text.Len() + 1; }
347 virtual wxString GetText() const { return m_text; }
348 virtual void SetText(const wxString& text) { m_text = text; }
349
350 // implement base class pure virtuals
351 // ----------------------------------
352
353 // some platforms have 2 and not 1 format for text data
354 #if wxUSE_UNICODE && (defined(__WXGTK20__) || defined(__WXMAC__))
355 virtual size_t GetFormatCount(Direction WXUNUSED(dir) = Get) const { return 2; }
356 virtual void GetAllFormats(wxDataFormat *formats,
357 wxDataObjectBase::Direction WXUNUSED(dir) = Get) const;
358
359 virtual size_t GetDataSize() const { return GetDataSize(GetPreferredFormat()); }
360 virtual bool GetDataHere(void *buf) const { return GetDataHere(GetPreferredFormat(), buf); }
361 virtual bool SetData(size_t len, const void *buf) { return SetData(GetPreferredFormat(), len, buf); }
362
363 size_t GetDataSize(const wxDataFormat& format) const;
364 bool GetDataHere(const wxDataFormat& format, void *pBuf) const;
365 bool SetData(const wxDataFormat& format, size_t nLen, const void* pBuf);
366 #else
367 virtual size_t GetDataSize() const;
368 virtual bool GetDataHere(void *buf) const;
369 virtual bool SetData(size_t len, const void *buf);
370 // Must provide overloads to avoid hiding them (and warnings about it)
371 virtual size_t GetDataSize(const wxDataFormat&) const
372 {
373 return GetDataSize();
374 }
375 virtual bool GetDataHere(const wxDataFormat&, void *buf) const
376 {
377 return GetDataHere(buf);
378 }
379 virtual bool SetData(const wxDataFormat&, size_t len, const void *buf)
380 {
381 return SetData(len, buf);
382 }
383 #endif
384
385 private:
386 wxString m_text;
387
388 DECLARE_NO_COPY_CLASS(wxTextDataObject)
389 };
390
391 // ----------------------------------------------------------------------------
392 // wxBitmapDataObject contains a bitmap
393 // ----------------------------------------------------------------------------
394
395 class WXDLLEXPORT wxBitmapDataObjectBase : public wxDataObjectSimple
396 {
397 public:
398 // ctor: you can specify the bitmap here or in SetBitmap(), or override
399 // GetBitmap()
400 wxBitmapDataObjectBase(const wxBitmap& bitmap = wxNullBitmap)
401 : wxDataObjectSimple(wxDF_BITMAP), m_bitmap(bitmap)
402 {
403 }
404
405 // virtual functions which you may override if you want to provide data on
406 // demand only - otherwise, the trivial default versions will be used
407 virtual wxBitmap GetBitmap() const { return m_bitmap; }
408 virtual void SetBitmap(const wxBitmap& bitmap) { m_bitmap = bitmap; }
409
410 protected:
411 wxBitmap m_bitmap;
412
413 DECLARE_NO_COPY_CLASS(wxBitmapDataObjectBase)
414 };
415
416 // ----------------------------------------------------------------------------
417 // wxFileDataObject contains a list of filenames
418 //
419 // NB: notice that this is a "write only" object, it can only be filled with
420 // data from drag and drop operation.
421 // ----------------------------------------------------------------------------
422
423 class WXDLLEXPORT wxFileDataObjectBase : public wxDataObjectSimple
424 {
425 public:
426 // ctor: use AddFile() later to fill the array
427 wxFileDataObjectBase() : wxDataObjectSimple(wxDF_FILENAME) { }
428
429 // get a reference to our array
430 const wxArrayString& GetFilenames() const { return m_filenames; }
431
432 protected:
433 wxArrayString m_filenames;
434
435 DECLARE_NO_COPY_CLASS(wxFileDataObjectBase)
436 };
437
438 // ----------------------------------------------------------------------------
439 // wxCustomDataObject contains arbitrary untyped user data.
440 //
441 // It is understood that this data can be copied bitwise.
442 // ----------------------------------------------------------------------------
443
444 class WXDLLEXPORT wxCustomDataObject : public wxDataObjectSimple
445 {
446 public:
447 // if you don't specify the format in the ctor, you can still use
448 // SetFormat() later
449 wxCustomDataObject(const wxDataFormat& format = wxFormatInvalid);
450
451 // the dtor calls Free()
452 virtual ~wxCustomDataObject();
453
454 // you can call SetData() to set m_data: it will make a copy of the data
455 // you pass - or you can use TakeData() which won't copy anything, but
456 // will take ownership of data (i.e. will call Free() on it later)
457 void TakeData(size_t size, void *data);
458
459 // this function is called to allocate "size" bytes of memory from
460 // SetData(). The default version uses operator new[].
461 virtual void *Alloc(size_t size);
462
463 // this function is called when the data is freed, you may override it to
464 // anything you want (or may be nothing at all). The default version calls
465 // operator delete[] on m_data
466 virtual void Free();
467
468 // get data: you may override these functions if you wish to provide data
469 // only when it's requested
470 virtual size_t GetSize() const { return m_size; }
471 virtual void *GetData() const { return m_data; }
472
473 // implement base class pure virtuals
474 // ----------------------------------
475 virtual size_t GetDataSize() const;
476 virtual bool GetDataHere(void *buf) const;
477 virtual bool SetData(size_t size, const void *buf);
478 // Must provide overloads to avoid hiding them (and warnings about it)
479 virtual size_t GetDataSize(const wxDataFormat&) const
480 {
481 return GetDataSize();
482 }
483 virtual bool GetDataHere(const wxDataFormat&, void *buf) const
484 {
485 return GetDataHere(buf);
486 }
487 virtual bool SetData(const wxDataFormat&, size_t len, const void *buf)
488 {
489 return SetData(len, buf);
490 }
491
492 private:
493 size_t m_size;
494 void *m_data;
495
496 DECLARE_NO_COPY_CLASS(wxCustomDataObject)
497 };
498
499 // ----------------------------------------------------------------------------
500 // include platform-specific declarations of wxXXXBase classes
501 // ----------------------------------------------------------------------------
502
503 #if defined(__WXMSW__)
504 #include "wx/msw/ole/dataobj2.h"
505
506 // wxURLDataObject defined in msw/ole/dataobj2.h
507 #else // !__WXMSW__
508 #if defined(__WXGTK20__)
509 #include "wx/gtk/dataobj2.h"
510 #elif defined(__WXGTK__)
511 #include "wx/gtk1/dataobj2.h"
512 #elif defined(__WXX11__)
513 #include "wx/x11/dataobj2.h"
514 #elif defined(__WXMOTIF__)
515 #include "wx/motif/dataobj2.h"
516 #elif defined(__WXMAC__)
517 #include "wx/mac/dataobj2.h"
518 #elif defined(__WXCOCOA__)
519 #include "wx/cocoa/dataobj2.h"
520 #elif defined(__WXPM__)
521 #include "wx/os2/dataobj2.h"
522 #endif
523
524 // wxURLDataObject is simply wxTextDataObject with a different name
525 class WXDLLEXPORT wxURLDataObject : public wxTextDataObject
526 {
527 public:
528 wxURLDataObject(const wxString& url = wxEmptyString)
529 : wxTextDataObject(url)
530 {
531 }
532
533 wxString GetURL() const { return GetText(); }
534 void SetURL(const wxString& url) { SetText(url); }
535 };
536 #endif // __WXMSW__/!__WXMSW__
537
538 #endif // wxUSE_DATAOBJ
539
540 #endif // _WX_DATAOBJ_H_BASE_

  ViewVC Help
Powered by ViewVC 1.1.22