]>
Commit | Line | Data |
---|---|---|
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 | ||
22 | class WXDLLIMPEXP_FWD_BASE wxObject; | |
23 | class WXDLLIMPEXP_FWD_BASE wxString; | |
24 | ||
25 | #ifndef wxUSE_EXTENDED_RTTI | |
26 | #define wxUSE_EXTENDED_RTTI 0 | |
27 | #endif | |
28 | ||
29 | #define DECLARE_CLASS_INFO_ITERATORS() \ | |
30 | class WXDLLIMPEXP_BASE const_iterator \ | |
31 | { \ | |
32 | typedef wxHashTable_Node Node; \ | |
33 | public: \ | |
34 | typedef const wxClassInfo* value_type; \ | |
35 | typedef const value_type& const_reference; \ | |
36 | typedef const_iterator itor; \ | |
37 | typedef value_type* ptr_type; \ | |
38 | \ | |
39 | Node* m_node; \ | |
40 | wxHashTable* m_table; \ | |
41 | public: \ | |
42 | typedef const_reference reference_type; \ | |
43 | typedef ptr_type pointer_type; \ | |
44 | \ | |
45 | const_iterator(Node* node, wxHashTable* table) \ | |
46 | : m_node(node), m_table(table) { } \ | |
47 | const_iterator() : m_node(NULL), m_table(NULL) { } \ | |
48 | value_type operator*() const; \ | |
49 | itor& operator++(); \ | |
50 | const itor operator++(int); \ | |
51 | bool operator!=(const itor& it) const \ | |
52 | { return it.m_node != m_node; } \ | |
53 | bool operator==(const itor& it) const \ | |
54 | { return it.m_node == m_node; } \ | |
55 | }; \ | |
56 | \ | |
57 | static const_iterator begin_classinfo(); \ | |
58 | static const_iterator end_classinfo(); | |
59 | ||
60 | #if wxUSE_EXTENDED_RTTI | |
61 | #include "wx/xti.h" | |
62 | #else | |
63 | ||
64 | // ---------------------------------------------------------------------------- | |
65 | // conditional compilation | |
66 | // ---------------------------------------------------------------------------- | |
67 | ||
68 | class WXDLLIMPEXP_FWD_BASE wxClassInfo; | |
69 | class WXDLLIMPEXP_FWD_BASE wxHashTable; | |
70 | class WXDLLIMPEXP_FWD_BASE wxObject; | |
71 | class WXDLLIMPEXP_FWD_BASE wxPluginLibrary; | |
72 | class WXDLLIMPEXP_FWD_BASE wxHashTable_Node; | |
73 | ||
74 | // ---------------------------------------------------------------------------- | |
75 | // wxClassInfo | |
76 | // ---------------------------------------------------------------------------- | |
77 | ||
78 | typedef wxObject *(*wxObjectConstructorFn)(void); | |
79 | ||
80 | class WXDLLIMPEXP_BASE wxClassInfo | |
81 | { | |
82 | friend class WXDLLIMPEXP_FWD_BASE wxObject; | |
83 | friend WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxString& name); | |
84 | public: | |
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 wxString& 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() | |
134 | private: | |
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 | ||
152 | protected: | |
153 | // registers the class | |
154 | void Register(); | |
155 | void Unregister(); | |
156 | ||
157 | wxDECLARE_NO_COPY_CLASS(wxClassInfo); | |
158 | }; | |
159 | ||
160 | WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxString& 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 | 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) \ | |
253 | class exportdecl name##PluginSentinel { \ | |
254 | private: \ | |
255 | static const wxString sm_className; \ | |
256 | public: \ | |
257 | name##PluginSentinel(); \ | |
258 | ~name##PluginSentinel(); \ | |
259 | }; \ | |
260 | name##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, WXDLLIMPEXP_CORE) | |
281 | #define DECLARE_ABSTRACT_PLUGGABLE_CLASS(name) \ | |
282 | DECLARE_ABSTRACT_CLASS(name) _DECLARE_DL_SENTINEL(name, WXDLLIMPEXP_CORE) | |
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 | const_cast<wxObject *>(static_cast<const wxObject *>(\ | |
322 | const_cast<className *>(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 | // FIXME-VC6: dummy argument needed because VC6 doesn't support explicitly | |
331 | // choosing the template function to call | |
332 | template <class T> | |
333 | inline T *wxCheckCast(const void *ptr, T * = NULL) | |
334 | { | |
335 | wxASSERT_MSG( wxDynamicCast(ptr, T), "wxStaticCast() used incorrectly" ); | |
336 | return const_cast<T *>(static_cast<const T *>(ptr)); | |
337 | } | |
338 | ||
339 | #define wxStaticCast(obj, className) wxCheckCast((obj), (className *)NULL) | |
340 | ||
341 | // ---------------------------------------------------------------------------- | |
342 | // set up memory debugging macros | |
343 | // ---------------------------------------------------------------------------- | |
344 | ||
345 | /* | |
346 | Which new/delete operator variants do we want? | |
347 | ||
348 | _WX_WANT_NEW_SIZET_WXCHAR_INT = void *operator new (size_t size, wxChar *fileName = 0, int lineNum = 0) | |
349 | _WX_WANT_DELETE_VOID = void operator delete (void * buf) | |
350 | _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET = void operator delete (void *buf, const char *_fname, size_t _line) | |
351 | _WX_WANT_DELETE_VOID_WXCHAR_INT = void operator delete(void *buf, wxChar*, int) | |
352 | _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT = void *operator new[] (size_t size, wxChar *fileName , int lineNum = 0) | |
353 | _WX_WANT_ARRAY_DELETE_VOID = void operator delete[] (void *buf) | |
354 | _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT = void operator delete[] (void* buf, wxChar*, int ) | |
355 | */ | |
356 | ||
357 | #if wxUSE_MEMORY_TRACING | |
358 | ||
359 | // All compilers get this one | |
360 | #define _WX_WANT_NEW_SIZET_WXCHAR_INT | |
361 | ||
362 | // Everyone except Visage gets the next one | |
363 | #ifndef __VISAGECPP__ | |
364 | #define _WX_WANT_DELETE_VOID | |
365 | #endif | |
366 | ||
367 | // Only visage gets this one under the correct circumstances | |
368 | #if defined(__VISAGECPP__) && __DEBUG_ALLOC__ | |
369 | #define _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET | |
370 | #endif | |
371 | ||
372 | // Only VC++ 6 and CodeWarrior get overloaded delete that matches new | |
373 | #if (defined(__VISUALC__) && (__VISUALC__ >= 1200)) || \ | |
374 | (defined(__MWERKS__) && (__MWERKS__ >= 0x2400)) | |
375 | #define _WX_WANT_DELETE_VOID_WXCHAR_INT | |
376 | #endif | |
377 | ||
378 | // Now see who (if anyone) gets the array memory operators | |
379 | #if wxUSE_ARRAY_MEMORY_OPERATORS | |
380 | ||
381 | // Everyone except Visual C++ (cause problems for VC++ - crashes) | |
382 | #if !defined(__VISUALC__) | |
383 | #define _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT | |
384 | #endif | |
385 | ||
386 | // Everyone except Visual C++ (cause problems for VC++ - crashes) | |
387 | #if !defined(__VISUALC__) | |
388 | #define _WX_WANT_ARRAY_DELETE_VOID | |
389 | #endif | |
390 | ||
391 | // Only CodeWarrior 6 or higher | |
392 | #if defined(__MWERKS__) && (__MWERKS__ >= 0x2400) | |
393 | #define _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT | |
394 | #endif | |
395 | ||
396 | #endif // wxUSE_ARRAY_MEMORY_OPERATORS | |
397 | ||
398 | #endif // wxUSE_MEMORY_TRACING | |
399 | ||
400 | // ---------------------------------------------------------------------------- | |
401 | // wxRefCounter: ref counted data "manager" | |
402 | // ---------------------------------------------------------------------------- | |
403 | ||
404 | class WXDLLIMPEXP_BASE wxRefCounter | |
405 | { | |
406 | public: | |
407 | wxRefCounter() { m_count = 1; } | |
408 | ||
409 | int GetRefCount() const { return m_count; } | |
410 | ||
411 | void IncRef() { m_count++; } | |
412 | void DecRef(); | |
413 | ||
414 | protected: | |
415 | // this object should never be destroyed directly but only as a | |
416 | // result of a DecRef() call: | |
417 | virtual ~wxRefCounter() { } | |
418 | ||
419 | private: | |
420 | // our refcount: | |
421 | int m_count; | |
422 | }; | |
423 | ||
424 | // ---------------------------------------------------------------------------- | |
425 | // wxObjectRefData: ref counted data meant to be stored in wxObject | |
426 | // ---------------------------------------------------------------------------- | |
427 | ||
428 | typedef wxRefCounter wxObjectRefData; | |
429 | ||
430 | ||
431 | // ---------------------------------------------------------------------------- | |
432 | // wxObjectDataPtr: helper class to avoid memleaks because of missing calls | |
433 | // to wxObjectRefData::DecRef | |
434 | // ---------------------------------------------------------------------------- | |
435 | ||
436 | template <class T> | |
437 | class wxObjectDataPtr | |
438 | { | |
439 | public: | |
440 | typedef T element_type; | |
441 | ||
442 | wxEXPLICIT wxObjectDataPtr(T *ptr = NULL) : m_ptr(ptr) {} | |
443 | ||
444 | // copy ctor | |
445 | wxObjectDataPtr(const wxObjectDataPtr<T> &tocopy) | |
446 | : m_ptr(tocopy.m_ptr) | |
447 | { | |
448 | if (m_ptr) | |
449 | m_ptr->IncRef(); | |
450 | } | |
451 | ||
452 | ~wxObjectDataPtr() | |
453 | { | |
454 | if (m_ptr) | |
455 | m_ptr->DecRef(); | |
456 | } | |
457 | ||
458 | T *get() const { return m_ptr; } | |
459 | ||
460 | // test for pointer validity: defining conversion to unspecified_bool_type | |
461 | // and not more obvious bool to avoid implicit conversions to integer types | |
462 | typedef T *(wxObjectDataPtr<T>::*unspecified_bool_type)() const; | |
463 | operator unspecified_bool_type() const | |
464 | { | |
465 | return m_ptr ? &wxObjectDataPtr<T>::get : NULL; | |
466 | } | |
467 | ||
468 | T& operator*() const | |
469 | { | |
470 | wxASSERT(m_ptr != NULL); | |
471 | return *(m_ptr); | |
472 | } | |
473 | ||
474 | T *operator->() const | |
475 | { | |
476 | wxASSERT(m_ptr != NULL); | |
477 | return get(); | |
478 | } | |
479 | ||
480 | void reset(T *ptr) | |
481 | { | |
482 | if (m_ptr) | |
483 | m_ptr->DecRef(); | |
484 | m_ptr = ptr; | |
485 | } | |
486 | ||
487 | wxObjectDataPtr& operator=(const wxObjectDataPtr &tocopy) | |
488 | { | |
489 | if (m_ptr) | |
490 | m_ptr->DecRef(); | |
491 | m_ptr = tocopy.m_ptr; | |
492 | if (m_ptr) | |
493 | m_ptr->IncRef(); | |
494 | return *this; | |
495 | } | |
496 | ||
497 | wxObjectDataPtr& operator=(T *ptr) | |
498 | { | |
499 | if (m_ptr) | |
500 | m_ptr->DecRef(); | |
501 | m_ptr = ptr; | |
502 | return *this; | |
503 | } | |
504 | ||
505 | private: | |
506 | T *m_ptr; | |
507 | }; | |
508 | ||
509 | // ---------------------------------------------------------------------------- | |
510 | // wxObject: the root class of wxWidgets object hierarchy | |
511 | // ---------------------------------------------------------------------------- | |
512 | ||
513 | class WXDLLIMPEXP_BASE wxObject | |
514 | { | |
515 | DECLARE_ABSTRACT_CLASS(wxObject) | |
516 | ||
517 | public: | |
518 | wxObject() { m_refData = NULL; } | |
519 | virtual ~wxObject() { UnRef(); } | |
520 | ||
521 | wxObject(const wxObject& other) | |
522 | { | |
523 | m_refData = other.m_refData; | |
524 | if (m_refData) | |
525 | m_refData->IncRef(); | |
526 | } | |
527 | ||
528 | wxObject& operator=(const wxObject& other) | |
529 | { | |
530 | if ( this != &other ) | |
531 | { | |
532 | Ref(other); | |
533 | } | |
534 | return *this; | |
535 | } | |
536 | ||
537 | bool IsKindOf(const wxClassInfo *info) const; | |
538 | ||
539 | ||
540 | // Turn on the correct set of new and delete operators | |
541 | ||
542 | #ifdef _WX_WANT_NEW_SIZET_WXCHAR_INT | |
543 | void *operator new ( size_t size, const wxChar *fileName = NULL, int lineNum = 0 ); | |
544 | #endif | |
545 | ||
546 | #ifdef _WX_WANT_DELETE_VOID | |
547 | void operator delete ( void * buf ); | |
548 | #endif | |
549 | ||
550 | #ifdef _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET | |
551 | void operator delete ( void *buf, const char *_fname, size_t _line ); | |
552 | #endif | |
553 | ||
554 | #ifdef _WX_WANT_DELETE_VOID_WXCHAR_INT | |
555 | void operator delete ( void *buf, const wxChar*, int ); | |
556 | #endif | |
557 | ||
558 | #ifdef _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT | |
559 | void *operator new[] ( size_t size, const wxChar *fileName = NULL, int lineNum = 0 ); | |
560 | #endif | |
561 | ||
562 | #ifdef _WX_WANT_ARRAY_DELETE_VOID | |
563 | void operator delete[] ( void *buf ); | |
564 | #endif | |
565 | ||
566 | #ifdef _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT | |
567 | void operator delete[] (void* buf, const wxChar*, int ); | |
568 | #endif | |
569 | ||
570 | // ref counted data handling methods | |
571 | ||
572 | // get/set | |
573 | wxObjectRefData *GetRefData() const { return m_refData; } | |
574 | void SetRefData(wxObjectRefData *data) { m_refData = data; } | |
575 | ||
576 | // make a 'clone' of the object | |
577 | void Ref(const wxObject& clone); | |
578 | ||
579 | // destroy a reference | |
580 | void UnRef(); | |
581 | ||
582 | // Make sure this object has only one reference | |
583 | void UnShare() { AllocExclusive(); } | |
584 | ||
585 | // check if this object references the same data as the other one | |
586 | bool IsSameAs(const wxObject& o) const { return m_refData == o.m_refData; } | |
587 | ||
588 | protected: | |
589 | // ensure that our data is not shared with anybody else: if we have no | |
590 | // data, it is created using CreateRefData() below, if we have shared data | |
591 | // it is copied using CloneRefData(), otherwise nothing is done | |
592 | void AllocExclusive(); | |
593 | ||
594 | // both methods must be implemented if AllocExclusive() is used, not pure | |
595 | // virtual only because of the backwards compatibility reasons | |
596 | ||
597 | // create a new m_refData | |
598 | virtual wxObjectRefData *CreateRefData() const; | |
599 | ||
600 | // create a new m_refData initialized with the given one | |
601 | virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const; | |
602 | ||
603 | wxObjectRefData *m_refData; | |
604 | }; | |
605 | ||
606 | inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo) | |
607 | { | |
608 | return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : NULL; | |
609 | } | |
610 | ||
611 | #if wxUSE_EXTENDED_RTTI | |
612 | class WXDLLIMPEXP_BASE wxDynamicObject : public wxObject | |
613 | { | |
614 | friend class WXDLLIMPEXP_FWD_BASE wxDynamicClassInfo ; | |
615 | public: | |
616 | // instantiates this object with an instance of its superclass | |
617 | wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info) ; | |
618 | virtual ~wxDynamicObject(); | |
619 | ||
620 | void SetProperty (const wxChar *propertyName, const wxxVariant &value); | |
621 | wxxVariant GetProperty (const wxChar *propertyName) const ; | |
622 | ||
623 | // get the runtime identity of this object | |
624 | wxClassInfo *GetClassInfo() const | |
625 | { | |
626 | #ifdef _MSC_VER | |
627 | return (wxClassInfo*) m_classInfo; | |
628 | #else | |
629 | wxDynamicClassInfo *nonconst = const_cast<wxDynamicClassInfo *>(m_classInfo); | |
630 | return static_cast<wxClassInfo *>(nonconst); | |
631 | #endif | |
632 | } | |
633 | ||
634 | wxObject* GetSuperClassInstance() const | |
635 | { | |
636 | return m_superClassInstance ; | |
637 | } | |
638 | private : | |
639 | // removes an existing runtime-property | |
640 | void RemoveProperty( const wxChar *propertyName ) ; | |
641 | ||
642 | // renames an existing runtime-property | |
643 | void RenameProperty( const wxChar *oldPropertyName , const wxChar *newPropertyName ) ; | |
644 | ||
645 | wxObject *m_superClassInstance ; | |
646 | const wxDynamicClassInfo *m_classInfo; | |
647 | struct wxDynamicObjectInternal; | |
648 | wxDynamicObjectInternal *m_data; | |
649 | }; | |
650 | #endif | |
651 | ||
652 | // ---------------------------------------------------------------------------- | |
653 | // more debugging macros | |
654 | // ---------------------------------------------------------------------------- | |
655 | ||
656 | #if wxUSE_DEBUG_NEW_ALWAYS | |
657 | #define WXDEBUG_NEW new(__TFILE__,__LINE__) | |
658 | ||
659 | #if wxUSE_GLOBAL_MEMORY_OPERATORS | |
660 | #define new WXDEBUG_NEW | |
661 | #elif defined(__VISUALC__) | |
662 | // Including this file redefines new and allows leak reports to | |
663 | // contain line numbers | |
664 | #include "wx/msw/msvcrt.h" | |
665 | #endif | |
666 | #endif // wxUSE_DEBUG_NEW_ALWAYS | |
667 | ||
668 | #endif // _WX_OBJECTH__ |