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