/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/dataobj.h
ViewVC logotype

Annotation of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/dataobj.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (hide annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (9 years, 10 months ago) by william
Original Path: trunk/3rdparty/wxWidgets/include/wx/dataobj.h
File MIME type: text/plain
File size: 20547 byte(s)
committing r3113 initial commit again...
1 william 31 ///////////////////////////////////////////////////////////////////////////////
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