| 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_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 | |
| 36 | class WXDLLIMPEXP_BASE wxClassInfo; |
| 37 | class WXDLLIMPEXP_BASE wxHashTable; |
| 38 | class WXDLLIMPEXP_BASE wxObjectRefData; |
| 39 | |
| 40 | // ---------------------------------------------------------------------------- |
| 41 | // wxClassInfo |
| 42 | // ---------------------------------------------------------------------------- |
| 43 | |
| 44 | typedef wxObject *(*wxObjectConstructorFn)(void); |
| 45 | |
| 46 | class WXDLLIMPEXP_BASE wxClassInfo |
| 47 | { |
| 48 | public: |
| 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 | |
| 104 | public: |
| 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 | |
| 124 | private: |
| 125 | // InitializeClasses() helper |
| 126 | static wxClassInfo *GetBaseByName(const wxChar *name); |
| 127 | |
| 128 | DECLARE_NO_COPY_CLASS(wxClassInfo) |
| 129 | |
| 130 | protected: |
| 131 | // registers the class |
| 132 | void Register(); |
| 133 | void Unregister(); |
| 134 | }; |
| 135 | |
| 136 | WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name); |
| 137 | |
| 138 | #if WXWIN_COMPATIBILITY_2_4 |
| 139 | inline void wxClassInfo::InitializeClasses() {} |
| 140 | inline 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) \ |
| 234 | class exportdecl name##PluginSentinel { \ |
| 235 | private: \ |
| 236 | static const wxString sm_className; \ |
| 237 | public: \ |
| 238 | name##PluginSentinel(); \ |
| 239 | ~name##PluginSentinel(); \ |
| 240 | }; \ |
| 241 | name##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__ |
| 312 | inline 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 | |
| 389 | class WXDLLIMPEXP_BASE wxObjectRefData |
| 390 | { |
| 391 | friend class WXDLLIMPEXP_BASE wxObject; |
| 392 | |
| 393 | public: |
| 394 | wxObjectRefData() : m_count(1) { } |
| 395 | virtual ~wxObjectRefData() { } |
| 396 | |
| 397 | int GetRefCount() const { return m_count; } |
| 398 | |
| 399 | private: |
| 400 | int m_count; |
| 401 | }; |
| 402 | |
| 403 | // ---------------------------------------------------------------------------- |
| 404 | // wxObject: the root class of wxWidgets object hierarchy |
| 405 | // ---------------------------------------------------------------------------- |
| 406 | |
| 407 | class WXDLLIMPEXP_BASE wxObject |
| 408 | { |
| 409 | DECLARE_ABSTRACT_CLASS(wxObject) |
| 410 | |
| 411 | public: |
| 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 | |
| 482 | protected: |
| 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 | |
| 500 | inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo) |
| 501 | { |
| 502 | return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : NULL; |
| 503 | } |
| 504 | |
| 505 | #if wxUSE_EXTENDED_RTTI |
| 506 | class WXDLLIMPEXP_BASE wxDynamicObject : public wxObject |
| 507 | { |
| 508 | friend class WXDLLIMPEXP_BASE wxDynamicClassInfo ; |
| 509 | public: |
| 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 | } |
| 531 | private : |
| 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__ |