]> 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
adding measuring contexts, streamlining printing code
[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#if wxUSE_EXTENDED_RTTI
29#include "wx/xti.h"
30#else
31
32// ----------------------------------------------------------------------------
33// conditional compilation
34// ----------------------------------------------------------------------------
35
36class WXDLLIMPEXP_BASE wxClassInfo;
37class WXDLLIMPEXP_BASE wxHashTable;
38class WXDLLIMPEXP_BASE wxObjectRefData;
39
40// ----------------------------------------------------------------------------
41// wxClassInfo
42// ----------------------------------------------------------------------------
43
44typedef wxObject *(*wxObjectConstructorFn)(void);
45
46class WXDLLIMPEXP_BASE wxClassInfo
47{
48public:
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
67 wxObject *CreateObject() const
68 { return m_objectConstructor ? (*m_objectConstructor)() : 0; }
69 bool IsDynamic() const { return (NULL != m_objectConstructor); }
70
71 const wxChar *GetClassName() const { return m_className; }
72 const wxChar *GetBaseClassName1() const
73 { return m_baseInfo1 ? m_baseInfo1->GetClassName() : NULL; }
74 const wxChar *GetBaseClassName2() const
75 { return m_baseInfo2 ? m_baseInfo2->GetClassName() : NULL; }
76 const wxClassInfo *GetBaseClass1() const { return m_baseInfo1; }
77 const wxClassInfo *GetBaseClass2() const { return m_baseInfo2; }
78 int GetSize() const { return m_objectSize; }
79
80 wxObjectConstructorFn GetConstructor() const
81 { return m_objectConstructor; }
82 static const wxClassInfo *GetFirst() { return sm_first; }
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
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
104public:
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
124private:
125 // InitializeClasses() helper
126 static wxClassInfo *GetBaseByName(const wxChar *name);
127
128 DECLARE_NO_COPY_CLASS(wxClassInfo)
129
130protected:
131 // registers the class
132 void Register();
133 void Unregister();
134};
135
136WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
137
138#if WXWIN_COMPATIBILITY_2_4
139inline void wxClassInfo::InitializeClasses() {}
140inline 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) \
234class exportdecl name##PluginSentinel { \
235private: \
236 static const wxString sm_className; \
237public: \
238 name##PluginSentinel(); \
239 ~name##PluginSentinel(); \
240}; \
241name##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__
312inline void* wxCheckCast(void *ptr)
313{
314 wxASSERT_MSG( ptr, _T("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
389class WXDLLIMPEXP_BASE wxObjectRefData
390{
391 friend class WXDLLIMPEXP_BASE wxObject;
392
393public:
394 wxObjectRefData() : m_count(1) { }
395 virtual ~wxObjectRefData() { }
396
397 int GetRefCount() const { return m_count; }
398
399private:
400 int m_count;
401};
402
403// ----------------------------------------------------------------------------
404// wxObject: the root class of wxWidgets object hierarchy
405// ----------------------------------------------------------------------------
406
407class WXDLLIMPEXP_BASE wxObject
408{
409 DECLARE_ABSTRACT_CLASS(wxObject)
410
411public:
412 wxObject() { m_refData = NULL; }
413 virtual ~wxObject() { UnRef(); }
414
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
467 wxObjectRefData *GetRefData() const { return m_refData; }
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
477 void UnShare() { AllocExclusive(); }
478
479 // check if this object references the same data as the other one
480 bool IsSameAs(const wxObject& o) const { return m_refData == o.m_refData; }
481
482protected:
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
500inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo)
501{
502 return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : NULL;
503}
504
505#if wxUSE_EXTENDED_RTTI
506class WXDLLIMPEXP_BASE wxDynamicObject : public wxObject
507{
508 friend class WXDLLIMPEXP_BASE wxDynamicClassInfo ;
509public:
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
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
527 wxObject* GetSuperClassInstance() const
528 {
529 return m_superClassInstance ;
530 }
531private :
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__
wxWidgets (Impactor)