]> git.saurik.com Git - wxWidgets.git/blame - include/wx/object.h
support SDK < 10.6, fixes #14902
[wxWidgets.git] / include / wx / object.h
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
b2edef6f 2// Name: wx/object.h
c801d85f
KB
3// Purpose: wxObject class, plus run-time type information macros
4// Author: Julian Smart
0b9ab0bd 5// Modified by: Ron Lee
c801d85f
KB
6// Created: 01/02/97
7// RCS-ID: $Id$
371a5b4e 8// Copyright: (c) 1997 Julian Smart
0b9ab0bd 9// (c) 2001 Ron Lee <ron@debian.org>
65571936 10// Licence: wxWindows licence
c801d85f
KB
11/////////////////////////////////////////////////////////////////////////////
12
34138703
JS
13#ifndef _WX_OBJECTH__
14#define _WX_OBJECTH__
c801d85f 15
0b9ab0bd
RL
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
e55ad60e 20#include "wx/memory.h"
c801d85f 21
f06d6937
SC
22#define wxDECLARE_CLASS_INFO_ITERATORS() \
23class WXDLLIMPEXP_BASE const_iterator \
24 { \
25 typedef wxHashTable_Node Node; \
26 public: \
27 typedef const wxClassInfo* value_type; \
28 typedef const value_type& const_reference; \
29 typedef const_iterator itor; \
30 typedef value_type* ptr_type; \
31 \
32 Node* m_node; \
33 wxHashTable* m_table; \
34 public: \
35 typedef const_reference reference_type; \
36 typedef ptr_type pointer_type; \
37 \
38 const_iterator(Node* node, wxHashTable* table) \
39 : m_node(node), m_table(table) { } \
40 const_iterator() : m_node(NULL), m_table(NULL) { } \
41 value_type operator*() const; \
42 itor& operator++(); \
43 const itor operator++(int); \
44 bool operator!=(const itor& it) const \
45 { return it.m_node != m_node; } \
46 bool operator==(const itor& it) const \
47 { return it.m_node == m_node; } \
48 }; \
49 \
50 static const_iterator begin_classinfo(); \
51 static const_iterator end_classinfo()
52
28953245
SC
53// based on the value of wxUSE_EXTENDED_RTTI symbol,
54// only one of the RTTI system will be compiled:
55// - the "old" one (defined by rtti.h) or
56// - the "new" one (defined by xti.h)
a095505c 57#include "wx/xti.h"
28953245 58#include "wx/rtti.h"
a095505c 59
cbca59a8
SC
60#define wxIMPLEMENT_CLASS(name, basename) \
61 wxIMPLEMENT_ABSTRACT_CLASS(name, basename)
62
63#define wxIMPLEMENT_CLASS2(name, basename1, basename2) \
64 wxIMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2)
65
0b9ab0bd
RL
66// -----------------------------------
67// for pluggable classes
68// -----------------------------------
69
70 // NOTE: this should probably be the very first statement
71 // in the class declaration so wxPluginSentinel is
72 // the first member initialised and the last destroyed.
73
74// _DECLARE_DL_SENTINEL(name) wxPluginSentinel m_pluginsentinel;
75
76#if wxUSE_NESTED_CLASSES
77
60b73526
RL
78#define _DECLARE_DL_SENTINEL(name, exportdecl) \
79class exportdecl name##PluginSentinel { \
80private: \
81 static const wxString sm_className; \
82public: \
83 name##PluginSentinel(); \
2e0b1b11 84 ~name##PluginSentinel(); \
60b73526 85}; \
b19b28c8 86name##PluginSentinel m_pluginsentinel
0b9ab0bd
RL
87
88#define _IMPLEMENT_DL_SENTINEL(name) \
89 const wxString name::name##PluginSentinel::sm_className(#name); \
90 name::name##PluginSentinel::name##PluginSentinel() { \
4f89dbc4 91 wxPluginLibrary *e = (wxPluginLibrary*) wxPluginLibrary::ms_classes.Get(#name); \
7c1e2b44 92 if( e != 0 ) { e->RefObj(); } \
0b9ab0bd 93 } \
abad5367 94 name::name##PluginSentinel::~name##PluginSentinel() { \
4f89dbc4 95 wxPluginLibrary *e = (wxPluginLibrary*) wxPluginLibrary::ms_classes.Get(#name); \
7c1e2b44 96 if( e != 0 ) { e->UnrefObj(); } \
0b9ab0bd
RL
97 }
98#else
99
100#define _DECLARE_DL_SENTINEL(name)
101#define _IMPLEMENT_DL_SENTINEL(name)
102
103#endif // wxUSE_NESTED_CLASSES
104
b19b28c8
FM
105#define wxDECLARE_PLUGGABLE_CLASS(name) \
106 wxDECLARE_DYNAMIC_CLASS(name); _DECLARE_DL_SENTINEL(name, WXDLLIMPEXP_CORE)
107#define wxDECLARE_ABSTRACT_PLUGGABLE_CLASS(name) \
108 wxDECLARE_ABSTRACT_CLASS(name); _DECLARE_DL_SENTINEL(name, WXDLLIMPEXP_CORE)
109
110#define wxDECLARE_USER_EXPORTED_PLUGGABLE_CLASS(name, usergoo) \
111 wxDECLARE_DYNAMIC_CLASS(name); _DECLARE_DL_SENTINEL(name, usergoo)
112#define wxDECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(name, usergoo) \
113 wxDECLARE_ABSTRACT_CLASS(name); _DECLARE_DL_SENTINEL(name, usergoo)
114
115#define wxIMPLEMENT_PLUGGABLE_CLASS(name, basename) \
116 wxIMPLEMENT_DYNAMIC_CLASS(name, basename) _IMPLEMENT_DL_SENTINEL(name)
117#define wxIMPLEMENT_PLUGGABLE_CLASS2(name, basename1, basename2) \
118 wxIMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) _IMPLEMENT_DL_SENTINEL(name)
119#define wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(name, basename) \
120 wxIMPLEMENT_ABSTRACT_CLASS(name, basename) _IMPLEMENT_DL_SENTINEL(name)
121#define wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2) \
122 wxIMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) _IMPLEMENT_DL_SENTINEL(name)
123
124#define wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(name, basename) \
125 wxIMPLEMENT_PLUGGABLE_CLASS(name, basename)
126#define wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(name, basename1, basename2) \
127 wxIMPLEMENT_PLUGGABLE_CLASS2(name, basename1, basename2)
128#define wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(name, basename) \
129 wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(name, basename)
130#define wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2) \
131 wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2)
132
133#define wxCLASSINFO(name) (&name::ms_classInfo)
c801d85f 134
c0db9626 135#define wxIS_KIND_OF(obj, className) obj->IsKindOf(&className::ms_classInfo)
3013b6f4 136
b2edef6f 137// Just seems a bit nicer-looking (pretend it's not a macro)
c0db9626 138#define wxIsKindOf(obj, className) obj->IsKindOf(&className::ms_classInfo)
c801d85f 139
73fbb031
VZ
140// this cast does some more checks at compile time as it uses static_cast
141// internally
142//
143// note that it still has different semantics from dynamic_cast<> and so can't
144// be replaced by it as long as there are any compilers not supporting it
34636400 145#define wxDynamicCast(obj, className) \
5232d996 146 ((className *) wxCheckDynamicCast( \
5c33522f
VZ
147 const_cast<wxObject *>(static_cast<const wxObject *>(\
148 const_cast<className *>(static_cast<const className *>(obj)))), \
5232d996 149 &className::ms_classInfo))
0b9ab0bd 150
b2edef6f
VZ
151// The 'this' pointer is always true, so use this version
152// to cast the this pointer and avoid compiler warnings.
f7637829 153#define wxDynamicCastThis(className) \
73fbb031 154 (IsKindOf(&className::ms_classInfo) ? (className *)(this) : (className *)0)
33ac7e6f 155
657a8a35
VZ
156// FIXME-VC6: dummy argument needed because VC6 doesn't support explicitly
157// choosing the template function to call
158template <class T>
159inline T *wxCheckCast(const void *ptr, T * = NULL)
0b9ab0bd 160{
657a8a35
VZ
161 wxASSERT_MSG( wxDynamicCast(ptr, T), "wxStaticCast() used incorrectly" );
162 return const_cast<T *>(static_cast<const T *>(ptr));
0b9ab0bd 163}
f6bcfd97 164
657a8a35 165#define wxStaticCast(obj, className) wxCheckCast((obj), (className *)NULL)
f6bcfd97 166
b2edef6f
VZ
167// ----------------------------------------------------------------------------
168// set up memory debugging macros
169// ----------------------------------------------------------------------------
170
171/*
172 Which new/delete operator variants do we want?
173
174 _WX_WANT_NEW_SIZET_WXCHAR_INT = void *operator new (size_t size, wxChar *fileName = 0, int lineNum = 0)
175 _WX_WANT_DELETE_VOID = void operator delete (void * buf)
176 _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET = void operator delete (void *buf, const char *_fname, size_t _line)
177 _WX_WANT_DELETE_VOID_WXCHAR_INT = void operator delete(void *buf, wxChar*, int)
178 _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT = void *operator new[] (size_t size, wxChar *fileName , int lineNum = 0)
179 _WX_WANT_ARRAY_DELETE_VOID = void operator delete[] (void *buf)
180 _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT = void operator delete[] (void* buf, wxChar*, int )
181*/
182
657a8a35 183#if wxUSE_MEMORY_TRACING
b2edef6f
VZ
184
185// All compilers get this one
186#define _WX_WANT_NEW_SIZET_WXCHAR_INT
187
188// Everyone except Visage gets the next one
189#ifndef __VISAGECPP__
190 #define _WX_WANT_DELETE_VOID
c801d85f 191#endif
b2edef6f
VZ
192
193// Only visage gets this one under the correct circumstances
194#if defined(__VISAGECPP__) && __DEBUG_ALLOC__
195 #define _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET
196#endif
197
2415cf67
VZ
198// Only VC++ 6 gets overloaded delete that matches new
199#if (defined(__VISUALC__) && (__VISUALC__ >= 1200))
b2edef6f 200 #define _WX_WANT_DELETE_VOID_WXCHAR_INT
fd85b064 201#endif
c801d85f 202
b2edef6f
VZ
203// Now see who (if anyone) gets the array memory operators
204#if wxUSE_ARRAY_MEMORY_OPERATORS
205
206 // Everyone except Visual C++ (cause problems for VC++ - crashes)
207 #if !defined(__VISUALC__)
208 #define _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT
209 #endif
210
211 // Everyone except Visual C++ (cause problems for VC++ - crashes)
212 #if !defined(__VISUALC__)
213 #define _WX_WANT_ARRAY_DELETE_VOID
214 #endif
b2edef6f
VZ
215#endif // wxUSE_ARRAY_MEMORY_OPERATORS
216
657a8a35 217#endif // wxUSE_MEMORY_TRACING
b2edef6f 218
cbca59a8
SC
219// ----------------------------------------------------------------------------
220// Compatibility macro aliases DECLARE group
221// ----------------------------------------------------------------------------
222// deprecated variants _not_ requiring a semicolon after them and without wx prefix.
223// (note that also some wx-prefixed macro do _not_ require a semicolon because
224// it's not always possible to force the compire to require it)
225
226#define DECLARE_CLASS_INFO_ITERATORS() wxDECLARE_CLASS_INFO_ITERATORS();
227#define DECLARE_ABSTRACT_CLASS(n) wxDECLARE_ABSTRACT_CLASS(n);
228#define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(n) wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(n);
229#define DECLARE_DYNAMIC_CLASS_NO_COPY(n) wxDECLARE_DYNAMIC_CLASS_NO_COPY(n);
230#define DECLARE_DYNAMIC_CLASS(n) wxDECLARE_DYNAMIC_CLASS(n);
231#define DECLARE_CLASS(n) wxDECLARE_CLASS(n);
232
233#define DECLARE_PLUGGABLE_CLASS(n) wxDECLARE_PLUGGABLE_CLASS(n);
234#define DECLARE_ABSTRACT_PLUGGABLE_CLASS(n) wxDECLARE_ABSTRACT_PLUGGABLE_CLASS(n);
235#define DECLARE_USER_EXPORTED_PLUGGABLE_CLASS(n,u) wxDECLARE_USER_EXPORTED_PLUGGABLE_CLASS(n,u);
236#define DECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,u) wxDECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,u);
237
f8855e47 238// ----------------------------------------------------------------------------
6d37c1b7 239// wxRefCounter: ref counted data "manager"
f8855e47
VZ
240// ----------------------------------------------------------------------------
241
6d37c1b7 242class WXDLLIMPEXP_BASE wxRefCounter
f8855e47 243{
f8855e47 244public:
6d37c1b7 245 wxRefCounter() { m_count = 1; }
f8855e47
VZ
246
247 int GetRefCount() const { return m_count; }
248
4a11340a
RR
249 void IncRef() { m_count++; }
250 void DecRef();
251
252protected:
253 // this object should never be destroyed directly but only as a
254 // result of a DecRef() call:
6d37c1b7 255 virtual ~wxRefCounter() { }
4a11340a 256
f8855e47 257private:
4a11340a 258 // our refcount:
f8855e47 259 int m_count;
fd08ccd2
VZ
260
261 // It doesn't make sense to copy the reference counted objects, a new ref
262 // counter should be created for a new object instead and compilation
263 // errors in the code using wxRefCounter due to the lack of copy ctor often
264 // indicate a problem, e.g. a forgotten copy ctor implementation somewhere.
265 wxDECLARE_NO_COPY_CLASS(wxRefCounter);
f8855e47
VZ
266};
267
6d37c1b7
RR
268// ----------------------------------------------------------------------------
269// wxObjectRefData: ref counted data meant to be stored in wxObject
270// ----------------------------------------------------------------------------
271
272typedef wxRefCounter wxObjectRefData;
273
4a11340a
RR
274// ----------------------------------------------------------------------------
275// wxObjectDataPtr: helper class to avoid memleaks because of missing calls
276// to wxObjectRefData::DecRef
277// ----------------------------------------------------------------------------
278
279template <class T>
280class wxObjectDataPtr
281{
282public:
283 typedef T element_type;
284
285 wxEXPLICIT wxObjectDataPtr(T *ptr = NULL) : m_ptr(ptr) {}
286
287 // copy ctor
53a2db12 288 wxObjectDataPtr(const wxObjectDataPtr<T> &tocopy)
4a11340a 289 : m_ptr(tocopy.m_ptr)
53a2db12 290 {
4a11340a 291 if (m_ptr)
53a2db12 292 m_ptr->IncRef();
4a11340a
RR
293 }
294
53a2db12
FM
295 ~wxObjectDataPtr()
296 {
297 if (m_ptr)
298 m_ptr->DecRef();
4a11340a
RR
299 }
300
301 T *get() const { return m_ptr; }
53a2db12 302
a60b0ddc
RR
303 // test for pointer validity: defining conversion to unspecified_bool_type
304 // and not more obvious bool to avoid implicit conversions to integer types
305 typedef T *(wxObjectDataPtr<T>::*unspecified_bool_type)() const;
306 operator unspecified_bool_type() const
307 {
308 return m_ptr ? &wxObjectDataPtr<T>::get : NULL;
309 }
310
311 T& operator*() const
53a2db12
FM
312 {
313 wxASSERT(m_ptr != NULL);
a60b0ddc
RR
314 return *(m_ptr);
315 }
53a2db12 316
e39d30c0 317 T *operator->() const
53a2db12
FM
318 {
319 wxASSERT(m_ptr != NULL);
320 return get();
e39d30c0 321 }
4a11340a
RR
322
323 void reset(T *ptr)
324 {
325 if (m_ptr)
326 m_ptr->DecRef();
327 m_ptr = ptr;
328 }
329
330 wxObjectDataPtr& operator=(const wxObjectDataPtr &tocopy)
53a2db12
FM
331 {
332 if (m_ptr)
333 m_ptr->DecRef();
334 m_ptr = tocopy.m_ptr;
4a11340a 335 if (m_ptr)
53a2db12 336 m_ptr->IncRef();
4a11340a
RR
337 return *this;
338 }
339
340 wxObjectDataPtr& operator=(T *ptr)
53a2db12
FM
341 {
342 if (m_ptr)
343 m_ptr->DecRef();
344 m_ptr = ptr;
4a11340a
RR
345 return *this;
346 }
347
348private:
349 T *m_ptr;
350};
351
0b9ab0bd 352// ----------------------------------------------------------------------------
77ffb593 353// wxObject: the root class of wxWidgets object hierarchy
0b9ab0bd
RL
354// ----------------------------------------------------------------------------
355
bddd7a8d 356class WXDLLIMPEXP_BASE wxObject
c801d85f 357{
b19b28c8 358 wxDECLARE_ABSTRACT_CLASS(wxObject);
c801d85f 359
0b9ab0bd 360public:
b2edef6f 361 wxObject() { m_refData = NULL; }
0b9ab0bd 362 virtual ~wxObject() { UnRef(); }
4393b50c 363
a6391d30 364 wxObject(const wxObject& other)
66e9a9f0 365 {
f8855e47
VZ
366 m_refData = other.m_refData;
367 if (m_refData)
6d37c1b7 368 m_refData->IncRef();
66e9a9f0 369 }
4393b50c 370
a6391d30
GD
371 wxObject& operator=(const wxObject& other)
372 {
373 if ( this != &other )
374 {
f8855e47 375 Ref(other);
a6391d30
GD
376 }
377 return *this;
378 }
379
303c6f20 380 bool IsKindOf(const wxClassInfo *info) const;
c801d85f 381
0b9ab0bd 382
b2edef6f
VZ
383 // Turn on the correct set of new and delete operators
384
385#ifdef _WX_WANT_NEW_SIZET_WXCHAR_INT
cf760e4c 386 void *operator new ( size_t size, const wxChar *fileName = NULL, int lineNum = 0 );
0b9ab0bd 387#endif
27198be4 388
b2edef6f
VZ
389#ifdef _WX_WANT_DELETE_VOID
390 void operator delete ( void * buf );
391#endif
0b9ab0bd 392
b2edef6f
VZ
393#ifdef _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET
394 void operator delete ( void *buf, const char *_fname, size_t _line );
0b9ab0bd 395#endif
76626af2 396
b2edef6f 397#ifdef _WX_WANT_DELETE_VOID_WXCHAR_INT
cf760e4c 398 void operator delete ( void *buf, const wxChar*, int );
b2edef6f 399#endif
8cfc5426 400
b2edef6f 401#ifdef _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT
cf760e4c 402 void *operator new[] ( size_t size, const wxChar *fileName = NULL, int lineNum = 0 );
0b9ab0bd
RL
403#endif
404
b2edef6f
VZ
405#ifdef _WX_WANT_ARRAY_DELETE_VOID
406 void operator delete[] ( void *buf );
0b9ab0bd 407#endif
27198be4 408
b2edef6f 409#ifdef _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT
cf760e4c 410 void operator delete[] (void* buf, const wxChar*, int );
b2edef6f 411#endif
c801d85f 412
807d8487
VZ
413 // ref counted data handling methods
414
415 // get/set
416 wxObjectRefData *GetRefData() const { return m_refData; }
417 void SetRefData(wxObjectRefData *data) { m_refData = data; }
418
419 // make a 'clone' of the object
0b9ab0bd 420 void Ref(const wxObject& clone);
c801d85f 421
807d8487 422 // destroy a reference
0b9ab0bd 423 void UnRef();
c801d85f 424
93c5f755
PC
425 // Make sure this object has only one reference
426 void UnShare() { AllocExclusive(); }
427
a3ab1c18
VZ
428 // check if this object references the same data as the other one
429 bool IsSameAs(const wxObject& o) const { return m_refData == o.m_refData; }
55ccdb93 430
c801d85f 431protected:
807d8487
VZ
432 // ensure that our data is not shared with anybody else: if we have no
433 // data, it is created using CreateRefData() below, if we have shared data
434 // it is copied using CloneRefData(), otherwise nothing is done
435 void AllocExclusive();
436
4e124582
VZ
437 // both methods must be implemented if AllocExclusive() is used, not pure
438 // virtual only because of the backwards compatibility reasons
807d8487
VZ
439
440 // create a new m_refData
441 virtual wxObjectRefData *CreateRefData() const;
442
443 // create a new m_refData initialized with the given one
b8027888 444 virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
807d8487 445
0b9ab0bd 446 wxObjectRefData *m_refData;
c801d85f
KB
447};
448
ea1e6c4b
RL
449inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo)
450{
b2edef6f 451 return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : NULL;
ea1e6c4b
RL
452}
453
cbca59a8 454#include "wx/xti2.h"
2d51f067 455
b2edef6f
VZ
456// ----------------------------------------------------------------------------
457// more debugging macros
458// ----------------------------------------------------------------------------
459
657a8a35 460#if wxUSE_DEBUG_NEW_ALWAYS
70bf6180
VZ
461 #define WXDEBUG_NEW new(__TFILE__,__LINE__)
462
657a8a35
VZ
463 #if wxUSE_GLOBAL_MEMORY_OPERATORS
464 #define new WXDEBUG_NEW
465 #elif defined(__VISUALC__)
466 // Including this file redefines new and allows leak reports to
467 // contain line numbers
468 #include "wx/msw/msvcrt.h"
469 #endif
470#endif // wxUSE_DEBUG_NEW_ALWAYS
c801d85f 471
b19b28c8 472// ----------------------------------------------------------------------------
cbca59a8 473// Compatibility macro aliases IMPLEMENT group
b19b28c8
FM
474// ----------------------------------------------------------------------------
475
476// deprecated variants _not_ requiring a semicolon after them and without wx prefix.
477// (note that also some wx-prefixed macro do _not_ require a semicolon because
478// it's not always possible to force the compire to require it)
479
b19b28c8
FM
480#define IMPLEMENT_DYNAMIC_CLASS(n,b) wxIMPLEMENT_DYNAMIC_CLASS(n,b)
481#define IMPLEMENT_DYNAMIC_CLASS2(n,b1,b2) wxIMPLEMENT_DYNAMIC_CLASS2(n,b1,b2)
482#define IMPLEMENT_ABSTRACT_CLASS(n,b) wxIMPLEMENT_ABSTRACT_CLASS(n,b)
483#define IMPLEMENT_ABSTRACT_CLASS2(n,b1,b2) wxIMPLEMENT_ABSTRACT_CLASS2(n,b1,b2)
484#define IMPLEMENT_CLASS(n,b) wxIMPLEMENT_CLASS(n,b)
485#define IMPLEMENT_CLASS2(n,b1,b2) wxIMPLEMENT_CLASS2(n,b1,b2)
486
b19b28c8
FM
487#define IMPLEMENT_PLUGGABLE_CLASS(n,b) wxIMPLEMENT_PLUGGABLE_CLASS(n,b)
488#define IMPLEMENT_PLUGGABLE_CLASS2(n,b,b2) wxIMPLEMENT_PLUGGABLE_CLASS2(n,b,b2)
489#define IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(n,b) wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(n,b)
490#define IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2) wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2)
491#define IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(n,b) wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(n,b)
492#define IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(n,b,b2) wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(n,b,b2)
493#define IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,b) wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,b)
494#define IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2) wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2)
495
496#define CLASSINFO(n) wxCLASSINFO(n)
497
c0089c96 498#endif // _WX_OBJECTH__