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