]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/object.h
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Change SetValue( wxVariant &value ) to
[wxWidgets.git] / include / wx / object.h
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/object.h
3// Purpose: wxObject class, plus run-time type information macros
4// Author: Julian Smart
5// Modified by: Ron Lee
6// Created: 01/02/97
7// RCS-ID: $Id$
8// Copyright: (c) 1997 Julian Smart
9// (c) 2001 Ron Lee <ron@debian.org>
10// Licence: wxWindows licence
11/////////////////////////////////////////////////////////////////////////////
12
13#ifndef _WX_OBJECTH__
14#define _WX_OBJECTH__
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20#include "wx/memory.h"
21
22class WXDLLIMPEXP_BASE wxObject;
23
24#ifndef wxUSE_EXTENDED_RTTI
25#define wxUSE_EXTENDED_RTTI 0
26#endif
27
28#define DECLARE_CLASS_INFO_ITERATORS() \
29 class WXDLLIMPEXP_BASE const_iterator \
30 { \
31 typedef wxHashTable_Node Node; \
32 public: \
33 typedef const wxClassInfo* value_type; \
34 typedef const value_type& const_reference; \
35 typedef const_iterator itor; \
36 typedef value_type* ptr_type; \
37 \
38 Node* m_node; \
39 wxHashTable* m_table; \
40 public: \
41 typedef const_reference reference_type; \
42 typedef ptr_type pointer_type; \
43 \
44 const_iterator(Node* node, wxHashTable* table) \
45 : m_node(node), m_table(table) { } \
46 const_iterator() : m_node(NULL), m_table(NULL) { } \
47 value_type operator*() const; \
48 itor& operator++(); \
49 const itor operator++(int); \
50 bool operator!=(const itor& it) const \
51 { return it.m_node != m_node; } \
52 bool operator==(const itor& it) const \
53 { return it.m_node == m_node; } \
54 }; \
55 \
56 static const_iterator begin_classinfo(); \
57 static const_iterator end_classinfo();
58
59#if wxUSE_EXTENDED_RTTI
60#include "wx/xti.h"
61#else
62
63// ----------------------------------------------------------------------------
64// conditional compilation
65// ----------------------------------------------------------------------------
66
67class WXDLLIMPEXP_BASE wxClassInfo;
68class WXDLLIMPEXP_BASE wxHashTable;
69class WXDLLIMPEXP_BASE wxObject;
70class WXDLLIMPEXP_BASE wxPluginLibrary;
71class WXDLLIMPEXP_BASE wxObjectRefData;
72class WXDLLIMPEXP_BASE wxHashTable_Node;
73
74// ----------------------------------------------------------------------------
75// wxClassInfo
76// ----------------------------------------------------------------------------
77
78typedef wxObject *(*wxObjectConstructorFn)(void);
79
80class WXDLLIMPEXP_BASE wxClassInfo
81{
82 friend class WXDLLIMPEXP_BASE wxObject;
83 friend WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
84public:
85 wxClassInfo( const wxChar *className,
86 const wxClassInfo *baseInfo1,
87 const wxClassInfo *baseInfo2,
88 int size,
89 wxObjectConstructorFn ctor )
90 : m_className(className)
91 , m_objectSize(size)
92 , m_objectConstructor(ctor)
93 , m_baseInfo1(baseInfo1)
94 , m_baseInfo2(baseInfo2)
95 , m_next(sm_first)
96 {
97 sm_first = this;
98 Register();
99 }
100
101 ~wxClassInfo();
102
103 wxObject *CreateObject() const
104 { return m_objectConstructor ? (*m_objectConstructor)() : 0; }
105 bool IsDynamic() const { return (NULL != m_objectConstructor); }
106
107 const wxChar *GetClassName() const { return m_className; }
108 const wxChar *GetBaseClassName1() const
109 { return m_baseInfo1 ? m_baseInfo1->GetClassName() : NULL; }
110 const wxChar *GetBaseClassName2() const
111 { return m_baseInfo2 ? m_baseInfo2->GetClassName() : NULL; }
112 const wxClassInfo *GetBaseClass1() const { return m_baseInfo1; }
113 const wxClassInfo *GetBaseClass2() const { return m_baseInfo2; }
114 int GetSize() const { return m_objectSize; }
115
116 wxObjectConstructorFn GetConstructor() const
117 { return m_objectConstructor; }
118 static const wxClassInfo *GetFirst() { return sm_first; }
119 const wxClassInfo *GetNext() const { return m_next; }
120 static wxClassInfo *FindClass(const wxChar *className);
121
122 // Climb upwards through inheritance hierarchy.
123 // Dual inheritance is catered for.
124
125 bool IsKindOf(const wxClassInfo *info) const
126 {
127 return info != 0 &&
128 ( info == this ||
129 ( m_baseInfo1 && m_baseInfo1->IsKindOf(info) ) ||
130 ( m_baseInfo2 && m_baseInfo2->IsKindOf(info) ) );
131 }
132
133 DECLARE_CLASS_INFO_ITERATORS()
134private:
135 const wxChar *m_className;
136 int m_objectSize;
137 wxObjectConstructorFn m_objectConstructor;
138
139 // Pointers to base wxClassInfos
140
141 const wxClassInfo *m_baseInfo1;
142 const wxClassInfo *m_baseInfo2;
143
144 // class info object live in a linked list:
145 // pointers to its head and the next element in it
146
147 static wxClassInfo *sm_first;
148 wxClassInfo *m_next;
149
150 static wxHashTable *sm_classTable;
151
152protected:
153 // registers the class
154 void Register();
155 void Unregister();
156
157 DECLARE_NO_COPY_CLASS(wxClassInfo)
158};
159
160WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
161
162// ----------------------------------------------------------------------------
163// Dynamic class macros
164// ----------------------------------------------------------------------------
165
166#define DECLARE_ABSTRACT_CLASS(name) \
167 public: \
168 static wxClassInfo ms_classInfo; \
169 virtual wxClassInfo *GetClassInfo() const;
170
171#define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name) \
172 DECLARE_NO_ASSIGN_CLASS(name) \
173 DECLARE_DYNAMIC_CLASS(name)
174
175#define DECLARE_DYNAMIC_CLASS_NO_COPY(name) \
176 DECLARE_NO_COPY_CLASS(name) \
177 DECLARE_DYNAMIC_CLASS(name)
178
179#define DECLARE_DYNAMIC_CLASS(name) \
180 DECLARE_ABSTRACT_CLASS(name) \
181 static wxObject* wxCreateObject();
182
183#define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
184
185
186// common part of the macros below
187#define wxIMPLEMENT_CLASS_COMMON(name, basename, baseclsinfo2, func) \
188 wxClassInfo name::ms_classInfo(wxT(#name), \
189 &basename::ms_classInfo, \
190 baseclsinfo2, \
191 (int) sizeof(name), \
192 (wxObjectConstructorFn) func); \
193 \
194 wxClassInfo *name::GetClassInfo() const \
195 { return &name::ms_classInfo; }
196
197#define wxIMPLEMENT_CLASS_COMMON1(name, basename, func) \
198 wxIMPLEMENT_CLASS_COMMON(name, basename, NULL, func)
199
200#define wxIMPLEMENT_CLASS_COMMON2(name, basename1, basename2, func) \
201 wxIMPLEMENT_CLASS_COMMON(name, basename1, &basename2::ms_classInfo, func)
202
203// -----------------------------------
204// for concrete classes
205// -----------------------------------
206
207 // Single inheritance with one base class
208#define IMPLEMENT_DYNAMIC_CLASS(name, basename) \
209 wxIMPLEMENT_CLASS_COMMON1(name, basename, name::wxCreateObject) \
210 wxObject* name::wxCreateObject() \
211 { return new name; }
212
213 // Multiple inheritance with two base classes
214#define IMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) \
215 wxIMPLEMENT_CLASS_COMMON2(name, basename1, basename2, \
216 name::wxCreateObject) \
217 wxObject* name::wxCreateObject() \
218 { return new name; }
219
220// -----------------------------------
221// for abstract classes
222// -----------------------------------
223
224 // Single inheritance with one base class
225
226#define IMPLEMENT_ABSTRACT_CLASS(name, basename) \
227 wxIMPLEMENT_CLASS_COMMON1(name, basename, NULL)
228
229 // Multiple inheritance with two base classes
230
231#define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
232 wxIMPLEMENT_CLASS_COMMON2(name, basename1, basename2, NULL)
233
234#define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
235#define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
236
237#endif // !wxUSE_EXTENDED_RTTI
238
239
240// -----------------------------------
241// for pluggable classes
242// -----------------------------------
243
244 // NOTE: this should probably be the very first statement
245 // in the class declaration so wxPluginSentinel is
246 // the first member initialised and the last destroyed.
247
248// _DECLARE_DL_SENTINEL(name) wxPluginSentinel m_pluginsentinel;
249
250#if wxUSE_NESTED_CLASSES
251
252#define _DECLARE_DL_SENTINEL(name, exportdecl) \
253class exportdecl name##PluginSentinel { \
254private: \
255 static const wxString sm_className; \
256public: \
257 name##PluginSentinel(); \
258 ~name##PluginSentinel(); \
259}; \
260name##PluginSentinel m_pluginsentinel;
261
262#define _IMPLEMENT_DL_SENTINEL(name) \
263 const wxString name::name##PluginSentinel::sm_className(#name); \
264 name::name##PluginSentinel::name##PluginSentinel() { \
265 wxPluginLibrary *e = (wxPluginLibrary*) wxPluginLibrary::ms_classes.Get(#name); \
266 if( e != 0 ) { e->RefObj(); } \
267 } \
268 name::name##PluginSentinel::~name##PluginSentinel() { \
269 wxPluginLibrary *e = (wxPluginLibrary*) wxPluginLibrary::ms_classes.Get(#name); \
270 if( e != 0 ) { e->UnrefObj(); } \
271 }
272#else
273
274#define _DECLARE_DL_SENTINEL(name)
275#define _IMPLEMENT_DL_SENTINEL(name)
276
277#endif // wxUSE_NESTED_CLASSES
278
279#define DECLARE_PLUGGABLE_CLASS(name) \
280 DECLARE_DYNAMIC_CLASS(name) _DECLARE_DL_SENTINEL(name, WXDLLEXPORT)
281#define DECLARE_ABSTRACT_PLUGGABLE_CLASS(name) \
282 DECLARE_ABSTRACT_CLASS(name) _DECLARE_DL_SENTINEL(name, WXDLLEXPORT)
283
284#define DECLARE_USER_EXPORTED_PLUGGABLE_CLASS(name, usergoo) \
285 DECLARE_DYNAMIC_CLASS(name) _DECLARE_DL_SENTINEL(name, usergoo)
286#define DECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(name, usergoo) \
287 DECLARE_ABSTRACT_CLASS(name) _DECLARE_DL_SENTINEL(name, usergoo)
288
289#define IMPLEMENT_PLUGGABLE_CLASS(name, basename) \
290 IMPLEMENT_DYNAMIC_CLASS(name, basename) _IMPLEMENT_DL_SENTINEL(name)
291#define IMPLEMENT_PLUGGABLE_CLASS2(name, basename1, basename2) \
292 IMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) _IMPLEMENT_DL_SENTINEL(name)
293#define IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(name, basename) \
294 IMPLEMENT_ABSTRACT_CLASS(name, basename) _IMPLEMENT_DL_SENTINEL(name)
295#define IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2) \
296 IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) _IMPLEMENT_DL_SENTINEL(name)
297
298#define IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(name, basename) \
299 IMPLEMENT_PLUGGABLE_CLASS(name, basename)
300#define IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(name, basename1, basename2) \
301 IMPLEMENT_PLUGGABLE_CLASS2(name, basename1, basename2)
302#define IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(name, basename) \
303 IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(name, basename)
304#define IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2) \
305 IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2)
306
307#define CLASSINFO(name) (&name::ms_classInfo)
308
309#define wxIS_KIND_OF(obj, className) obj->IsKindOf(&className::ms_classInfo)
310
311// Just seems a bit nicer-looking (pretend it's not a macro)
312#define wxIsKindOf(obj, className) obj->IsKindOf(&className::ms_classInfo)
313
314// this cast does some more checks at compile time as it uses static_cast
315// internally
316//
317// note that it still has different semantics from dynamic_cast<> and so can't
318// be replaced by it as long as there are any compilers not supporting it
319#define wxDynamicCast(obj, className) \
320 ((className *) wxCheckDynamicCast( \
321 wx_const_cast(wxObject *, wx_static_cast(const wxObject *, \
322 wx_const_cast(className *, wx_static_cast(const className *, obj)))), \
323 &className::ms_classInfo))
324
325// The 'this' pointer is always true, so use this version
326// to cast the this pointer and avoid compiler warnings.
327#define wxDynamicCastThis(className) \
328 (IsKindOf(&className::ms_classInfo) ? (className *)(this) : (className *)0)
329
330#ifdef __WXDEBUG__
331inline void* wxCheckCast(void *ptr)
332{
333 wxASSERT_MSG( ptr, _T("wxStaticCast() used incorrectly") );
334 return ptr;
335}
336#define wxStaticCast(obj, className) \
337 ((className *)wxCheckCast(wxDynamicCast(obj, className)))
338
339#else // !__WXDEBUG__
340#define wxStaticCast(obj, className) \
341 wx_const_cast(className *, wx_static_cast(const className *, obj))
342
343#endif // __WXDEBUG__
344
345// ----------------------------------------------------------------------------
346// set up memory debugging macros
347// ----------------------------------------------------------------------------
348
349/*
350 Which new/delete operator variants do we want?
351
352 _WX_WANT_NEW_SIZET_WXCHAR_INT = void *operator new (size_t size, wxChar *fileName = 0, int lineNum = 0)
353 _WX_WANT_DELETE_VOID = void operator delete (void * buf)
354 _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET = void operator delete (void *buf, const char *_fname, size_t _line)
355 _WX_WANT_DELETE_VOID_WXCHAR_INT = void operator delete(void *buf, wxChar*, int)
356 _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT = void *operator new[] (size_t size, wxChar *fileName , int lineNum = 0)
357 _WX_WANT_ARRAY_DELETE_VOID = void operator delete[] (void *buf)
358 _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT = void operator delete[] (void* buf, wxChar*, int )
359*/
360
361#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
362
363// All compilers get this one
364#define _WX_WANT_NEW_SIZET_WXCHAR_INT
365
366// Everyone except Visage gets the next one
367#ifndef __VISAGECPP__
368 #define _WX_WANT_DELETE_VOID
369#endif
370
371// Only visage gets this one under the correct circumstances
372#if defined(__VISAGECPP__) && __DEBUG_ALLOC__
373 #define _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET
374#endif
375
376// Only VC++ 6 and CodeWarrior get overloaded delete that matches new
377#if (defined(__VISUALC__) && (__VISUALC__ >= 1200)) || \
378 (defined(__MWERKS__) && (__MWERKS__ >= 0x2400))
379 #define _WX_WANT_DELETE_VOID_WXCHAR_INT
380#endif
381
382// Now see who (if anyone) gets the array memory operators
383#if wxUSE_ARRAY_MEMORY_OPERATORS
384
385 // Everyone except Visual C++ (cause problems for VC++ - crashes)
386 #if !defined(__VISUALC__)
387 #define _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT
388 #endif
389
390 // Everyone except Visual C++ (cause problems for VC++ - crashes)
391 #if !defined(__VISUALC__)
392 #define _WX_WANT_ARRAY_DELETE_VOID
393 #endif
394
395 // Only CodeWarrior 6 or higher
396 #if defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
397 #define _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT
398 #endif
399
400#endif // wxUSE_ARRAY_MEMORY_OPERATORS
401
402#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
403
404// ----------------------------------------------------------------------------
405// wxObjectRefData: ref counted data meant to be stored in wxObject
406// ----------------------------------------------------------------------------
407
408class WXDLLIMPEXP_BASE wxObjectRefData
409{
410 friend class WXDLLIMPEXP_BASE wxObject;
411
412public:
413 wxObjectRefData() : m_count(1) { }
414
415 int GetRefCount() const { return m_count; }
416
417 void IncRef() { m_count++; }
418 void DecRef();
419
420protected:
421 // this object should never be destroyed directly but only as a
422 // result of a DecRef() call:
423 virtual ~wxObjectRefData() { }
424
425private:
426 // our refcount:
427 int m_count;
428};
429
430// ----------------------------------------------------------------------------
431// wxObjectDataPtr: helper class to avoid memleaks because of missing calls
432// to wxObjectRefData::DecRef
433// ----------------------------------------------------------------------------
434
435template <class T>
436class wxObjectDataPtr
437{
438public:
439 typedef T element_type;
440
441 wxEXPLICIT wxObjectDataPtr(T *ptr = NULL) : m_ptr(ptr) {}
442
443 // copy ctor
444 wxObjectDataPtr(const wxObjectDataPtr<T> &tocopy)
445 : m_ptr(tocopy.m_ptr)
446 {
447 if (m_ptr)
448 m_ptr->IncRef();
449 }
450
451 ~wxObjectDataPtr()
452 {
453 if (m_ptr)
454 m_ptr->DecRef();
455 }
456
457 T *get() const { return m_ptr; }
458 T *operator->() const { return get(); }
459
460 void reset(T *ptr)
461 {
462 if (m_ptr)
463 m_ptr->DecRef();
464 m_ptr = ptr;
465 }
466
467 wxObjectDataPtr& operator=(const wxObjectDataPtr &tocopy)
468 {
469 if (m_ptr)
470 m_ptr->DecRef();
471 m_ptr = tocopy.m_ptr;
472 if (m_ptr)
473 m_ptr->IncRef();
474 return *this;
475 }
476
477 wxObjectDataPtr& operator=(T *ptr)
478 {
479 if (m_ptr)
480 m_ptr->DecRef();
481 m_ptr = ptr;
482 if (m_ptr)
483 m_ptr->IncRef();
484 return *this;
485 }
486
487private:
488 T *m_ptr;
489};
490
491// ----------------------------------------------------------------------------
492// wxObject: the root class of wxWidgets object hierarchy
493// ----------------------------------------------------------------------------
494
495class WXDLLIMPEXP_BASE wxObject
496{
497 DECLARE_ABSTRACT_CLASS(wxObject)
498
499public:
500 wxObject() { m_refData = NULL; }
501 virtual ~wxObject() { UnRef(); }
502
503 wxObject(const wxObject& other)
504 {
505 m_refData = other.m_refData;
506 if (m_refData)
507 m_refData->m_count++;
508 }
509
510 wxObject& operator=(const wxObject& other)
511 {
512 if ( this != &other )
513 {
514 Ref(other);
515 }
516 return *this;
517 }
518
519 bool IsKindOf(wxClassInfo *info) const;
520
521
522 // Turn on the correct set of new and delete operators
523
524#ifdef _WX_WANT_NEW_SIZET_WXCHAR_INT
525 void *operator new ( size_t size, const wxChar *fileName = NULL, int lineNum = 0 );
526#endif
527
528#ifdef _WX_WANT_DELETE_VOID
529 void operator delete ( void * buf );
530#endif
531
532#ifdef _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET
533 void operator delete ( void *buf, const char *_fname, size_t _line );
534#endif
535
536#ifdef _WX_WANT_DELETE_VOID_WXCHAR_INT
537 void operator delete ( void *buf, const wxChar*, int );
538#endif
539
540#ifdef _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT
541 void *operator new[] ( size_t size, const wxChar *fileName = NULL, int lineNum = 0 );
542#endif
543
544#ifdef _WX_WANT_ARRAY_DELETE_VOID
545 void operator delete[] ( void *buf );
546#endif
547
548#ifdef _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT
549 void operator delete[] (void* buf, const wxChar*, int );
550#endif
551
552 // ref counted data handling methods
553
554 // get/set
555 wxObjectRefData *GetRefData() const { return m_refData; }
556 void SetRefData(wxObjectRefData *data) { m_refData = data; }
557
558 // make a 'clone' of the object
559 void Ref(const wxObject& clone);
560
561 // destroy a reference
562 void UnRef();
563
564 // Make sure this object has only one reference
565 void UnShare() { AllocExclusive(); }
566
567 // check if this object references the same data as the other one
568 bool IsSameAs(const wxObject& o) const { return m_refData == o.m_refData; }
569
570protected:
571 // ensure that our data is not shared with anybody else: if we have no
572 // data, it is created using CreateRefData() below, if we have shared data
573 // it is copied using CloneRefData(), otherwise nothing is done
574 void AllocExclusive();
575
576 // both methods must be implemented if AllocExclusive() is used, not pure
577 // virtual only because of the backwards compatibility reasons
578
579 // create a new m_refData
580 virtual wxObjectRefData *CreateRefData() const;
581
582 // create a new m_refData initialized with the given one
583 virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
584
585 wxObjectRefData *m_refData;
586};
587
588inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo)
589{
590 return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : NULL;
591}
592
593#if wxUSE_EXTENDED_RTTI
594class WXDLLIMPEXP_BASE wxDynamicObject : public wxObject
595{
596 friend class WXDLLIMPEXP_BASE wxDynamicClassInfo ;
597public:
598 // instantiates this object with an instance of its superclass
599 wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info) ;
600 virtual ~wxDynamicObject();
601
602 void SetProperty (const wxChar *propertyName, const wxxVariant &value);
603 wxxVariant GetProperty (const wxChar *propertyName) const ;
604
605 // get the runtime identity of this object
606 wxClassInfo *GetClassInfo() const
607 {
608#ifdef _MSC_VER
609 return (wxClassInfo*) m_classInfo;
610#else
611 wxDynamicClassInfo *nonconst = wx_const_cast(wxDynamicClassInfo *, m_classInfo);
612 return wx_static_cast(wxClassInfo *, nonconst);
613#endif
614 }
615
616 wxObject* GetSuperClassInstance() const
617 {
618 return m_superClassInstance ;
619 }
620private :
621 // removes an existing runtime-property
622 void RemoveProperty( const wxChar *propertyName ) ;
623
624 // renames an existing runtime-property
625 void RenameProperty( const wxChar *oldPropertyName , const wxChar *newPropertyName ) ;
626
627 wxObject *m_superClassInstance ;
628 const wxDynamicClassInfo *m_classInfo;
629 struct wxDynamicObjectInternal;
630 wxDynamicObjectInternal *m_data;
631};
632#endif
633
634// ----------------------------------------------------------------------------
635// more debugging macros
636// ----------------------------------------------------------------------------
637
638// Redefine new to be the debugging version. This doesn't work with all
639// compilers, in which case you need to use WXDEBUG_NEW explicitly if you wish
640// to use the debugging version.
641
642#ifdef __WXDEBUG__
643 #define WXDEBUG_NEW new(__TFILE__,__LINE__)
644
645 #if wxUSE_DEBUG_NEW_ALWAYS
646 #if wxUSE_GLOBAL_MEMORY_OPERATORS
647 #define new WXDEBUG_NEW
648 #elif defined(__VISUALC__)
649 // Including this file redefines new and allows leak reports to
650 // contain line numbers
651 #include "wx/msw/msvcrt.h"
652 #endif
653 #endif // wxUSE_DEBUG_NEW_ALWAYS
654#else // !__WXDEBUG__
655 #define WXDEBUG_NEW new
656#endif // __WXDEBUG__/!__WXDEBUG__
657
658#endif // _WX_OBJECTH__
wxWidgets (Impactor)