]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: object.h | |
3 | // Purpose: wxObject class, plus run-time type information macros | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 01/02/97 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart and Markus Holzem | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifndef _WX_OBJECTH__ | |
13 | #define _WX_OBJECTH__ | |
14 | ||
15 | #ifdef __GNUG__ | |
16 | #pragma interface "object.h" | |
17 | #endif | |
18 | ||
19 | #include "wx/defs.h" | |
20 | #include "wx/memory.h" | |
21 | ||
22 | class WXDLLEXPORT wxObject; | |
23 | ||
24 | #if wxUSE_DYNAMIC_CLASSES | |
25 | ||
26 | // #ifdef __GNUWIN32__ | |
27 | #ifdef GetClassName | |
28 | #undef GetClassName | |
29 | #endif | |
30 | #ifdef GetClassInfo | |
31 | #undef GetClassInfo | |
32 | #endif | |
33 | // #endif | |
34 | ||
35 | class WXDLLEXPORT wxClassInfo; | |
36 | class WXDLLEXPORT wxInputStream; | |
37 | class WXDLLEXPORT wxOutputStream; | |
38 | class WXDLLEXPORT wxObjectInputStream; | |
39 | class WXDLLEXPORT wxObjectOutputStream; | |
40 | class WXDLLEXPORT wxHashTable; | |
41 | class WXDLLEXPORT wxObject_Serialize; | |
42 | ||
43 | #if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT) | |
44 | #include "wx/ioswrap.h" | |
45 | #endif | |
46 | ||
47 | /* | |
48 | * Dynamic object system declarations | |
49 | */ | |
50 | ||
51 | typedef wxObject * (*wxObjectConstructorFn) (void); | |
52 | ||
53 | class WXDLLEXPORT wxClassInfo | |
54 | { | |
55 | public: | |
56 | wxClassInfo(const wxChar *cName, | |
57 | const wxChar *baseName1, | |
58 | const wxChar *baseName2, | |
59 | int sz, | |
60 | wxObjectConstructorFn fn); | |
61 | ||
62 | wxObject *CreateObject(void); | |
63 | ||
64 | const wxChar *GetClassName() const { return m_className; } | |
65 | const wxChar *GetBaseClassName1() const { return m_baseClassName1; } | |
66 | const wxChar *GetBaseClassName2() const { return m_baseClassName2; } | |
67 | const wxClassInfo* GetBaseClass1() const { return m_baseInfo1; } | |
68 | const wxClassInfo* GetBaseClass2() const { return m_baseInfo2; } | |
69 | int GetSize() const { return m_objectSize; } | |
70 | wxObjectConstructorFn GetConstructor() const { return m_objectConstructor; } | |
71 | static const wxClassInfo* GetFirst() { return sm_first; } | |
72 | const wxClassInfo* GetNext() const { return m_next; } | |
73 | bool IsKindOf(const wxClassInfo *info) const; | |
74 | ||
75 | static wxClassInfo *FindClass(const wxChar *c); | |
76 | ||
77 | // Initializes parent pointers and hash table for fast searching. | |
78 | static void InitializeClasses(); | |
79 | ||
80 | // Cleans up hash table used for fast searching. | |
81 | static void CleanUpClasses(); | |
82 | ||
83 | public: | |
84 | const wxChar* m_className; | |
85 | const wxChar* m_baseClassName1; | |
86 | const wxChar* m_baseClassName2; | |
87 | int m_objectSize; | |
88 | wxObjectConstructorFn m_objectConstructor; | |
89 | ||
90 | // Pointers to base wxClassInfos: set in InitializeClasses | |
91 | const wxClassInfo* m_baseInfo1; | |
92 | const wxClassInfo* m_baseInfo2; | |
93 | ||
94 | // class info object live in a linked list: pointers to its head and the | |
95 | // next element in it | |
96 | static wxClassInfo* sm_first; | |
97 | wxClassInfo* m_next; | |
98 | ||
99 | static wxHashTable* sm_classTable; | |
100 | }; | |
101 | ||
102 | WXDLLEXPORT wxObject* wxCreateDynamicObject(const wxChar *name); | |
103 | ||
104 | #if wxUSE_SERIAL | |
105 | WXDLLEXPORT wxObject* wxCreateStoredObject( wxInputStream& stream ); | |
106 | #endif | |
107 | ||
108 | #define DECLARE_DYNAMIC_CLASS(name) \ | |
109 | public:\ | |
110 | static wxClassInfo sm_class##name;\ | |
111 | wxClassInfo *GetClassInfo() const \ | |
112 | { return &name::sm_class##name; } | |
113 | ||
114 | #define DECLARE_ABSTRACT_CLASS(name) DECLARE_DYNAMIC_CLASS(name) | |
115 | #define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name) | |
116 | ||
117 | ////// | |
118 | ////// for concrete classes | |
119 | ////// | |
120 | ||
121 | // Single inheritance with one base class | |
122 | #define IMPLEMENT_DYNAMIC_CLASS(name, basename) \ | |
123 | wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void) \ | |
124 | { return new name; }\ | |
125 | wxClassInfo name::sm_class##name((wxChar *) wxT(#name), (wxChar *) wxT(#basename), (wxChar *) NULL, (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name); | |
126 | ||
127 | // Multiple inheritance with two base classes | |
128 | #define IMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) \ | |
129 | wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void) \ | |
130 | { return new name; }\ | |
131 | wxClassInfo name::sm_class##name((wxChar *) wxT(#name), (wxChar *) wxT(#basename1), (wxChar *) wxT(#basename2), (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name); | |
132 | ||
133 | ////// | |
134 | ////// for abstract classes | |
135 | ////// | |
136 | ||
137 | // Single inheritance with one base class | |
138 | #define IMPLEMENT_ABSTRACT_CLASS(name, basename) \ | |
139 | wxClassInfo name::sm_class##name((wxChar *) wxT(#name), (wxChar *) wxT(#basename), \ | |
140 | (wxChar *) NULL, (int) sizeof(name), (wxObjectConstructorFn) NULL); | |
141 | ||
142 | // Multiple inheritance with two base classes | |
143 | #define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \ | |
144 | wxClassInfo name::sm_class##name((wxChar *) wxT(#name), (wxChar *) wxT(#basename1), \ | |
145 | (wxChar *) wxT(#basename2), (int) sizeof(name), (wxObjectConstructorFn) NULL); | |
146 | ||
147 | #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS | |
148 | #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2 | |
149 | ||
150 | #define CLASSINFO(name) (&name::sm_class##name) | |
151 | ||
152 | #else // !wxUSE_DYNAMIC_CLASSES | |
153 | ||
154 | // No dynamic class system: so stub out the macros | |
155 | #define DECLARE_DYNAMIC_CLASS(name) | |
156 | #define DECLARE_ABSTRACT_CLASS(name) | |
157 | #define DECLARE_CLASS(name) | |
158 | #define IMPLEMENT_DYNAMIC_CLASS(name, basename) | |
159 | #define IMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) | |
160 | #define IMPLEMENT_ABSTRACT_CLASS(name, basename) | |
161 | #define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) | |
162 | #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS | |
163 | #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2 | |
164 | ||
165 | #endif // wxUSE_DYNAMIC_CLASSES/!wxUSE_DYNAMIC_CLASSES | |
166 | ||
167 | #define wxIS_KIND_OF(obj, className) obj->IsKindOf(&className::sm_class##className) | |
168 | ||
169 | // Just seems a bit nicer-looking (pretend it's not a macro) | |
170 | #define wxIsKindOf(obj, className) obj->IsKindOf(&className::sm_class##className) | |
171 | ||
172 | // to be replaced by dynamic_cast<> in the future | |
173 | #define wxDynamicCast(obj, className) \ | |
174 | ((obj) && ((obj)->IsKindOf(&className::sm_class##className)) \ | |
175 | ? (className *)(obj) \ | |
176 | : (className *)0) | |
177 | ||
178 | #define wxConstCast(obj, className) ((className *)(obj)) | |
179 | ||
180 | #ifdef __WXDEBUG__ | |
181 | inline void wxCheckCast(void *ptr) | |
182 | { | |
183 | wxASSERT_MSG( ptr, _T("wxStaticCast() used incorrectly") ); | |
184 | } | |
185 | ||
186 | #define wxStaticCast(obj, className) \ | |
187 | (wxCheckCast(wxDynamicCast(obj, className)), ((className *)(obj))) | |
188 | ||
189 | #else // !Debug | |
190 | #define wxStaticCast(obj, className) ((className *)(obj)) | |
191 | #endif // Debug/!Debug | |
192 | ||
193 | // Unfortunately Borland seems to need this include. | |
194 | #ifdef __BORLANDC__ | |
195 | #if wxUSE_IOSTREAMH | |
196 | #include <iostream.h> | |
197 | #else | |
198 | #include <iostream> | |
199 | #endif | |
200 | #endif | |
201 | ||
202 | class WXDLLEXPORT wxObjectRefData; | |
203 | ||
204 | class WXDLLEXPORT wxObject | |
205 | { | |
206 | public: | |
207 | ||
208 | // This is equivalent to using the macro DECLARE_ABSTRACT_CLASS | |
209 | static wxClassInfo sm_classwxObject; | |
210 | ||
211 | wxObject(void); | |
212 | virtual ~wxObject(void); | |
213 | ||
214 | virtual wxClassInfo *GetClassInfo(void) const { return &sm_classwxObject; } | |
215 | wxObject *Clone(void) const; | |
216 | virtual void CopyObject(wxObject& object_dest) const; | |
217 | ||
218 | bool IsKindOf(wxClassInfo *info) const; | |
219 | ||
220 | #if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING | |
221 | void * operator new (size_t size, wxChar * fileName = NULL, int lineNum = 0); | |
222 | # if defined(__VISAGECPP__) | |
223 | # if __DEBUG_ALLOC__ | |
224 | void operator delete (void * buf,const char * _fname, size_t _line); | |
225 | # endif //__DEBUG_ALLOC__ | |
226 | # else // Everybody else | |
227 | void operator delete (void * buf); | |
228 | # endif // end of VISAGECPP | |
229 | ||
230 | // VC++ 6.0 | |
231 | # if defined(__VISUALC__) && (__VISUALC__ >= 1200) | |
232 | void operator delete(void *buf, wxChar*, int); | |
233 | # endif | |
234 | ||
235 | // Causes problems for VC++ | |
236 | # if wxUSE_ARRAY_MEMORY_OPERATORS && !defined(__VISUALC__) && !defined( __MWERKS__) | |
237 | void * operator new[] (size_t size, wxChar * fileName = NULL, int lineNum = 0); | |
238 | void operator delete[] (void * buf); | |
239 | # endif | |
240 | ||
241 | # ifdef __MWERKS__ | |
242 | void * operator new[] (size_t size, wxChar * fileName , int lineNum = 0); | |
243 | void * operator new[] (size_t size) { return operator new[] ( size , NULL , 0 ) ; } | |
244 | void operator delete[] (void * buf); | |
245 | # endif | |
246 | ||
247 | #endif // Debug & memory tracing | |
248 | ||
249 | #if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT) | |
250 | virtual void Dump(ostream& str); | |
251 | #endif | |
252 | ||
253 | #if wxUSE_SERIAL | |
254 | virtual void StoreObject( wxObjectOutputStream &stream ); | |
255 | virtual void LoadObject( wxObjectInputStream &stream ); | |
256 | #endif | |
257 | ||
258 | // make a 'clone' of the object | |
259 | void Ref(const wxObject& clone); | |
260 | ||
261 | // destroy a reference | |
262 | void UnRef(void); | |
263 | ||
264 | inline wxObjectRefData *GetRefData(void) const { return m_refData; } | |
265 | inline void SetRefData(wxObjectRefData *data) { m_refData = data; } | |
266 | ||
267 | protected: | |
268 | wxObjectRefData* m_refData; | |
269 | #if wxUSE_SERIAL | |
270 | wxObject_Serialize* m_serialObj; | |
271 | #endif | |
272 | }; | |
273 | ||
274 | /* | |
275 | * wxObjectData | |
276 | */ | |
277 | ||
278 | class WXDLLEXPORT wxObjectRefData { | |
279 | ||
280 | friend class wxObject; | |
281 | ||
282 | public: | |
283 | wxObjectRefData(void); | |
284 | virtual ~wxObjectRefData(void); | |
285 | ||
286 | inline int GetRefCount(void) const { return m_count; } | |
287 | private: | |
288 | int m_count; | |
289 | }; | |
290 | ||
291 | #ifdef __WXDEBUG__ | |
292 | #ifndef WXDEBUG_NEW | |
293 | #define WXDEBUG_NEW new(__TFILE__,__LINE__) | |
294 | #endif | |
295 | #else | |
296 | #define WXDEBUG_NEW new | |
297 | #endif | |
298 | ||
299 | // Redefine new to be the debugging version. This doesn't | |
300 | // work with all compilers, in which case you need to | |
301 | // use WXDEBUG_NEW explicitly if you wish to use the debugging version. | |
302 | ||
303 | #if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS | |
304 | #define new new(__TFILE__,__LINE__) | |
305 | #endif | |
306 | ||
307 | #endif | |
308 | // _WX_OBJECTH__ | |
309 | ||
310 |