]> git.saurik.com Git - wxWidgets.git/blame - include/wx/object.h
don't draw borders for bitmap buttons with wxBORDER_NONE style
[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
b5dbe15d
VS
22class WXDLLIMPEXP_FWD_BASE wxObject;
23class WXDLLIMPEXP_FWD_BASE wxString;
c801d85f 24
4393b50c 25#ifndef wxUSE_EXTENDED_RTTI
6d553b5f 26#define wxUSE_EXTENDED_RTTI 0
a095505c
SC
27#endif
28
644cb537
MB
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
6d553b5f 60#if wxUSE_EXTENDED_RTTI
a095505c 61#include "wx/xti.h"
a095505c
SC
62#else
63
0b9ab0bd
RL
64// ----------------------------------------------------------------------------
65// conditional compilation
66// ----------------------------------------------------------------------------
67
b5dbe15d
VS
68class WXDLLIMPEXP_FWD_BASE wxClassInfo;
69class WXDLLIMPEXP_FWD_BASE wxHashTable;
70class WXDLLIMPEXP_FWD_BASE wxObject;
71class WXDLLIMPEXP_FWD_BASE wxPluginLibrary;
b5dbe15d 72class WXDLLIMPEXP_FWD_BASE wxHashTable_Node;
c801d85f 73
0b9ab0bd
RL
74// ----------------------------------------------------------------------------
75// wxClassInfo
76// ----------------------------------------------------------------------------
77
78typedef wxObject *(*wxObjectConstructorFn)(void);
c801d85f 79
bddd7a8d 80class WXDLLIMPEXP_BASE wxClassInfo
c801d85f 81{
b5dbe15d 82 friend class WXDLLIMPEXP_FWD_BASE wxObject;
c1e10a22 83 friend WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxString& name);
aac65598 84public:
38befbee 85 wxClassInfo( const wxChar *className,
d1d738f1
VS
86 const wxClassInfo *baseInfo1,
87 const wxClassInfo *baseInfo2,
38befbee
RL
88 int size,
89 wxObjectConstructorFn ctor )
0b9ab0bd 90 : m_className(className)
0b9ab0bd
RL
91 , m_objectSize(size)
92 , m_objectConstructor(ctor)
d1d738f1
VS
93 , m_baseInfo1(baseInfo1)
94 , m_baseInfo2(baseInfo2)
0b9ab0bd 95 , m_next(sm_first)
7e548f6b 96 {
d1d738f1
VS
97 sm_first = this;
98 Register();
99 }
0b9ab0bd 100
aa4b7ef9 101 ~wxClassInfo();
1d2eddff 102
4e124582
VZ
103 wxObject *CreateObject() const
104 { return m_objectConstructor ? (*m_objectConstructor)() : 0; }
0c06c983 105 bool IsDynamic() const { return (NULL != m_objectConstructor); }
0b9ab0bd
RL
106
107 const wxChar *GetClassName() const { return m_className; }
469349b5
MB
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; }
0b9ab0bd
RL
112 const wxClassInfo *GetBaseClass1() const { return m_baseInfo1; }
113 const wxClassInfo *GetBaseClass2() const { return m_baseInfo2; }
114 int GetSize() const { return m_objectSize; }
115
4e124582
VZ
116 wxObjectConstructorFn GetConstructor() const
117 { return m_objectConstructor; }
0b9ab0bd
RL
118 static const wxClassInfo *GetFirst() { return sm_first; }
119 const wxClassInfo *GetNext() const { return m_next; }
c1e10a22 120 static wxClassInfo *FindClass(const wxString& className);
807d8487 121
0b9ab0bd
RL
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 }
3f4a0c5b 132
644cb537
MB
133 DECLARE_CLASS_INFO_ITERATORS()
134private:
0b9ab0bd 135 const wxChar *m_className;
0b9ab0bd
RL
136 int m_objectSize;
137 wxObjectConstructorFn m_objectConstructor;
138
1125dc3f 139 // Pointers to base wxClassInfos
0b9ab0bd
RL
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;
1f428942 151
7e548f6b 152protected:
d1d738f1
VS
153 // registers the class
154 void Register();
155 void Unregister();
1125dc3f 156
c0c133e1 157 wxDECLARE_NO_COPY_CLASS(wxClassInfo);
c801d85f
KB
158};
159
c1e10a22 160WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxString& name);
c801d85f 161
0b9ab0bd
RL
162// ----------------------------------------------------------------------------
163// Dynamic class macros
164// ----------------------------------------------------------------------------
165
14ca93a0
VZ
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) \
fc7a2a60
VZ
173 DECLARE_DYNAMIC_CLASS(name)
174
14ca93a0
VZ
175#define DECLARE_DYNAMIC_CLASS_NO_COPY(name) \
176 DECLARE_NO_COPY_CLASS(name) \
fc7a2a60
VZ
177 DECLARE_DYNAMIC_CLASS(name)
178
14ca93a0
VZ
179#define DECLARE_DYNAMIC_CLASS(name) \
180 DECLARE_ABSTRACT_CLASS(name) \
181 static wxObject* wxCreateObject();
182
c801d85f
KB
183#define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
184
14ca93a0
VZ
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), \
32bb5309 192 func); \
14ca93a0
VZ
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) \
2b199a38 201 wxIMPLEMENT_CLASS_COMMON(name, basename1, &basename2::ms_classInfo, func)
14ca93a0 202
0b9ab0bd
RL
203// -----------------------------------
204// for concrete classes
205// -----------------------------------
206
207 // Single inheritance with one base class
14ca93a0
VZ
208#define IMPLEMENT_DYNAMIC_CLASS(name, basename) \
209 wxIMPLEMENT_CLASS_COMMON1(name, basename, name::wxCreateObject) \
210 wxObject* name::wxCreateObject() \
211 { return new name; }
c801d85f 212
0b9ab0bd 213 // Multiple inheritance with two base classes
14ca93a0
VZ
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; }
c801d85f 219
0b9ab0bd
RL
220// -----------------------------------
221// for abstract classes
222// -----------------------------------
c801d85f 223
0b9ab0bd
RL
224 // Single inheritance with one base class
225
14ca93a0
VZ
226#define IMPLEMENT_ABSTRACT_CLASS(name, basename) \
227 wxIMPLEMENT_CLASS_COMMON1(name, basename, NULL)
0b9ab0bd
RL
228
229 // Multiple inheritance with two base classes
230
14ca93a0
VZ
231#define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
232 wxIMPLEMENT_CLASS_COMMON2(name, basename1, basename2, NULL)
c801d85f
KB
233
234#define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
235#define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
236
6d553b5f 237#endif // !wxUSE_EXTENDED_RTTI
a095505c
SC
238
239
0b9ab0bd
RL
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
60b73526
RL
252#define _DECLARE_DL_SENTINEL(name, exportdecl) \
253class exportdecl name##PluginSentinel { \
254private: \
255 static const wxString sm_className; \
256public: \
257 name##PluginSentinel(); \
2e0b1b11 258 ~name##PluginSentinel(); \
60b73526 259}; \
0b9ab0bd 260name##PluginSentinel m_pluginsentinel;
0b9ab0bd
RL
261
262#define _IMPLEMENT_DL_SENTINEL(name) \
263 const wxString name::name##PluginSentinel::sm_className(#name); \
264 name::name##PluginSentinel::name##PluginSentinel() { \
4f89dbc4 265 wxPluginLibrary *e = (wxPluginLibrary*) wxPluginLibrary::ms_classes.Get(#name); \
7c1e2b44 266 if( e != 0 ) { e->RefObj(); } \
0b9ab0bd 267 } \
abad5367 268 name::name##PluginSentinel::~name##PluginSentinel() { \
4f89dbc4 269 wxPluginLibrary *e = (wxPluginLibrary*) wxPluginLibrary::ms_classes.Get(#name); \
7c1e2b44 270 if( e != 0 ) { e->UnrefObj(); } \
0b9ab0bd
RL
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) \
53a2db12 280 DECLARE_DYNAMIC_CLASS(name) _DECLARE_DL_SENTINEL(name, WXDLLIMPEXP_CORE)
0b9ab0bd 281#define DECLARE_ABSTRACT_PLUGGABLE_CLASS(name) \
53a2db12 282 DECLARE_ABSTRACT_CLASS(name) _DECLARE_DL_SENTINEL(name, WXDLLIMPEXP_CORE)
60b73526
RL
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)
0b9ab0bd
RL
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)
0b9ab0bd
RL
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
60b73526
RL
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
c0db9626 307#define CLASSINFO(name) (&name::ms_classInfo)
c801d85f 308
c0db9626 309#define wxIS_KIND_OF(obj, className) obj->IsKindOf(&className::ms_classInfo)
3013b6f4 310
b2edef6f 311// Just seems a bit nicer-looking (pretend it's not a macro)
c0db9626 312#define wxIsKindOf(obj, className) obj->IsKindOf(&className::ms_classInfo)
c801d85f 313
73fbb031
VZ
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
34636400 319#define wxDynamicCast(obj, className) \
5232d996 320 ((className *) wxCheckDynamicCast( \
5c33522f
VZ
321 const_cast<wxObject *>(static_cast<const wxObject *>(\
322 const_cast<className *>(static_cast<const className *>(obj)))), \
5232d996 323 &className::ms_classInfo))
0b9ab0bd 324
b2edef6f
VZ
325// The 'this' pointer is always true, so use this version
326// to cast the this pointer and avoid compiler warnings.
f7637829 327#define wxDynamicCastThis(className) \
73fbb031 328 (IsKindOf(&className::ms_classInfo) ? (className *)(this) : (className *)0)
33ac7e6f 329
657a8a35
VZ
330// FIXME-VC6: dummy argument needed because VC6 doesn't support explicitly
331// choosing the template function to call
332template <class T>
333inline T *wxCheckCast(const void *ptr, T * = NULL)
0b9ab0bd 334{
657a8a35
VZ
335 wxASSERT_MSG( wxDynamicCast(ptr, T), "wxStaticCast() used incorrectly" );
336 return const_cast<T *>(static_cast<const T *>(ptr));
0b9ab0bd 337}
f6bcfd97 338
657a8a35 339#define wxStaticCast(obj, className) wxCheckCast((obj), (className *)NULL)
f6bcfd97 340
b2edef6f
VZ
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
657a8a35 357#if wxUSE_MEMORY_TRACING
b2edef6f
VZ
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
c801d85f 365#endif
b2edef6f
VZ
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
4e124582
VZ
372// Only VC++ 6 and CodeWarrior get overloaded delete that matches new
373#if (defined(__VISUALC__) && (__VISUALC__ >= 1200)) || \
374 (defined(__MWERKS__) && (__MWERKS__ >= 0x2400))
b2edef6f 375 #define _WX_WANT_DELETE_VOID_WXCHAR_INT
fd85b064 376#endif
c801d85f 377
b2edef6f
VZ
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
657a8a35 398#endif // wxUSE_MEMORY_TRACING
b2edef6f 399
f8855e47 400// ----------------------------------------------------------------------------
6d37c1b7 401// wxRefCounter: ref counted data "manager"
f8855e47
VZ
402// ----------------------------------------------------------------------------
403
6d37c1b7 404class WXDLLIMPEXP_BASE wxRefCounter
f8855e47 405{
f8855e47 406public:
6d37c1b7 407 wxRefCounter() { m_count = 1; }
f8855e47
VZ
408
409 int GetRefCount() const { return m_count; }
410
4a11340a
RR
411 void IncRef() { m_count++; }
412 void DecRef();
413
414protected:
415 // this object should never be destroyed directly but only as a
416 // result of a DecRef() call:
6d37c1b7 417 virtual ~wxRefCounter() { }
4a11340a 418
f8855e47 419private:
4a11340a 420 // our refcount:
f8855e47
VZ
421 int m_count;
422};
423
6d37c1b7
RR
424// ----------------------------------------------------------------------------
425// wxObjectRefData: ref counted data meant to be stored in wxObject
426// ----------------------------------------------------------------------------
427
428typedef wxRefCounter wxObjectRefData;
429
430
4a11340a
RR
431// ----------------------------------------------------------------------------
432// wxObjectDataPtr: helper class to avoid memleaks because of missing calls
433// to wxObjectRefData::DecRef
434// ----------------------------------------------------------------------------
435
436template <class T>
437class wxObjectDataPtr
438{
439public:
440 typedef T element_type;
441
442 wxEXPLICIT wxObjectDataPtr(T *ptr = NULL) : m_ptr(ptr) {}
443
444 // copy ctor
53a2db12 445 wxObjectDataPtr(const wxObjectDataPtr<T> &tocopy)
4a11340a 446 : m_ptr(tocopy.m_ptr)
53a2db12 447 {
4a11340a 448 if (m_ptr)
53a2db12 449 m_ptr->IncRef();
4a11340a
RR
450 }
451
53a2db12
FM
452 ~wxObjectDataPtr()
453 {
454 if (m_ptr)
455 m_ptr->DecRef();
4a11340a
RR
456 }
457
458 T *get() const { return m_ptr; }
53a2db12 459
a60b0ddc
RR
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
53a2db12
FM
469 {
470 wxASSERT(m_ptr != NULL);
a60b0ddc
RR
471 return *(m_ptr);
472 }
53a2db12 473
e39d30c0 474 T *operator->() const
53a2db12
FM
475 {
476 wxASSERT(m_ptr != NULL);
477 return get();
e39d30c0 478 }
4a11340a
RR
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)
53a2db12
FM
488 {
489 if (m_ptr)
490 m_ptr->DecRef();
491 m_ptr = tocopy.m_ptr;
4a11340a 492 if (m_ptr)
53a2db12 493 m_ptr->IncRef();
4a11340a
RR
494 return *this;
495 }
496
497 wxObjectDataPtr& operator=(T *ptr)
53a2db12
FM
498 {
499 if (m_ptr)
500 m_ptr->DecRef();
501 m_ptr = ptr;
4a11340a
RR
502 return *this;
503 }
504
505private:
506 T *m_ptr;
507};
508
0b9ab0bd 509// ----------------------------------------------------------------------------
77ffb593 510// wxObject: the root class of wxWidgets object hierarchy
0b9ab0bd
RL
511// ----------------------------------------------------------------------------
512
bddd7a8d 513class WXDLLIMPEXP_BASE wxObject
c801d85f 514{
684242c6 515 DECLARE_ABSTRACT_CLASS(wxObject)
c801d85f 516
0b9ab0bd 517public:
b2edef6f 518 wxObject() { m_refData = NULL; }
0b9ab0bd 519 virtual ~wxObject() { UnRef(); }
4393b50c 520
a6391d30 521 wxObject(const wxObject& other)
66e9a9f0 522 {
f8855e47
VZ
523 m_refData = other.m_refData;
524 if (m_refData)
6d37c1b7 525 m_refData->IncRef();
66e9a9f0 526 }
4393b50c 527
a6391d30
GD
528 wxObject& operator=(const wxObject& other)
529 {
530 if ( this != &other )
531 {
f8855e47 532 Ref(other);
a6391d30
GD
533 }
534 return *this;
535 }
536
303c6f20 537 bool IsKindOf(const wxClassInfo *info) const;
c801d85f 538
0b9ab0bd 539
b2edef6f
VZ
540 // Turn on the correct set of new and delete operators
541
542#ifdef _WX_WANT_NEW_SIZET_WXCHAR_INT
cf760e4c 543 void *operator new ( size_t size, const wxChar *fileName = NULL, int lineNum = 0 );
0b9ab0bd 544#endif
27198be4 545
b2edef6f
VZ
546#ifdef _WX_WANT_DELETE_VOID
547 void operator delete ( void * buf );
548#endif
0b9ab0bd 549
b2edef6f
VZ
550#ifdef _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET
551 void operator delete ( void *buf, const char *_fname, size_t _line );
0b9ab0bd 552#endif
76626af2 553
b2edef6f 554#ifdef _WX_WANT_DELETE_VOID_WXCHAR_INT
cf760e4c 555 void operator delete ( void *buf, const wxChar*, int );
b2edef6f 556#endif
8cfc5426 557
b2edef6f 558#ifdef _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT
cf760e4c 559 void *operator new[] ( size_t size, const wxChar *fileName = NULL, int lineNum = 0 );
0b9ab0bd
RL
560#endif
561
b2edef6f
VZ
562#ifdef _WX_WANT_ARRAY_DELETE_VOID
563 void operator delete[] ( void *buf );
0b9ab0bd 564#endif
27198be4 565
b2edef6f 566#ifdef _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT
cf760e4c 567 void operator delete[] (void* buf, const wxChar*, int );
b2edef6f 568#endif
c801d85f 569
807d8487
VZ
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
0b9ab0bd 577 void Ref(const wxObject& clone);
c801d85f 578
807d8487 579 // destroy a reference
0b9ab0bd 580 void UnRef();
c801d85f 581
93c5f755
PC
582 // Make sure this object has only one reference
583 void UnShare() { AllocExclusive(); }
584
a3ab1c18
VZ
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; }
55ccdb93 587
c801d85f 588protected:
807d8487
VZ
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
4e124582
VZ
594 // both methods must be implemented if AllocExclusive() is used, not pure
595 // virtual only because of the backwards compatibility reasons
807d8487
VZ
596
597 // create a new m_refData
598 virtual wxObjectRefData *CreateRefData() const;
599
600 // create a new m_refData initialized with the given one
b8027888 601 virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
807d8487 602
0b9ab0bd 603 wxObjectRefData *m_refData;
c801d85f
KB
604};
605
ea1e6c4b
RL
606inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo)
607{
b2edef6f 608 return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : NULL;
ea1e6c4b
RL
609}
610
2d51f067
SC
611#if wxUSE_EXTENDED_RTTI
612class WXDLLIMPEXP_BASE wxDynamicObject : public wxObject
613{
b5dbe15d 614 friend class WXDLLIMPEXP_FWD_BASE wxDynamicClassInfo ;
2d51f067
SC
615public:
616 // instantiates this object with an instance of its superclass
617 wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info) ;
d3c7fc99 618 virtual ~wxDynamicObject();
2d51f067 619
8f2b1cfd
SC
620 void SetProperty (const wxChar *propertyName, const wxxVariant &value);
621 wxxVariant GetProperty (const wxChar *propertyName) const ;
2d51f067
SC
622
623 // get the runtime identity of this object
624 wxClassInfo *GetClassInfo() const
625 {
f525dc35
JS
626#ifdef _MSC_VER
627 return (wxClassInfo*) m_classInfo;
628#else
5c33522f
VZ
629 wxDynamicClassInfo *nonconst = const_cast<wxDynamicClassInfo *>(m_classInfo);
630 return static_cast<wxClassInfo *>(nonconst);
f525dc35 631#endif
2d51f067
SC
632 }
633
634 wxObject* GetSuperClassInstance() const
635 {
636 return m_superClassInstance ;
637 }
638private :
8f2b1cfd
SC
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
2d51f067
SC
645 wxObject *m_superClassInstance ;
646 const wxDynamicClassInfo *m_classInfo;
647 struct wxDynamicObjectInternal;
648 wxDynamicObjectInternal *m_data;
649};
650#endif
651
b2edef6f
VZ
652// ----------------------------------------------------------------------------
653// more debugging macros
654// ----------------------------------------------------------------------------
655
657a8a35 656#if wxUSE_DEBUG_NEW_ALWAYS
70bf6180
VZ
657 #define WXDEBUG_NEW new(__TFILE__,__LINE__)
658
657a8a35
VZ
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
c801d85f 667
c0089c96 668#endif // _WX_OBJECTH__