include/wx/object.h

   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 // The 'this' pointer is always true, so use this version to cast the this
 179 // pointer and avoid compiler warnings.
 180 #define wxDynamicCastThis(className) \
 181         (IsKindOf(&className::sm_class##className) \
 182         ? (className *)(this) \
 183         : (className *)0)
 184
 185 #define wxConstCast(obj, className) ((className *)(obj))
 186
 187 #ifdef __WXDEBUG__
 188     inline void wxCheckCast(void *ptr)
 189     {
 190         wxASSERT_MSG( ptr, _T("wxStaticCast() used incorrectly") );
 191     }
 192
 193     #define wxStaticCast(obj, className) \
 194         (wxCheckCast(wxDynamicCast(obj, className)), ((className *)(obj)))
 195
 196 #else // !Debug
 197     #define wxStaticCast(obj, className) ((className *)(obj))
 198 #endif // Debug/!Debug
 199
 200 // Unfortunately Borland seems to need this include.
 201 #if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT)
 202 #ifdef __BORLANDC__
 203     #if wxUSE_IOSTREAMH
 204         #include <iostream.h>
 205     #else
 206         #include <iostream>
 207     #endif
 208 #endif
 209 #endif
 210
 211 class WXDLLEXPORT wxObjectRefData;
 212
 213 class WXDLLEXPORT wxObject
 214 {
 215  public:
 216
 217   // This is equivalent to using the macro DECLARE_ABSTRACT_CLASS
 218   static wxClassInfo sm_classwxObject;
 219
 220   wxObject(void);
 221   virtual ~wxObject(void);
 222
 223   virtual wxClassInfo *GetClassInfo(void) const { return &sm_classwxObject; }
 224   wxObject *Clone(void) const;
 225   virtual void CopyObject(wxObject& object_dest) const;
 226
 227   bool IsKindOf(wxClassInfo *info) const;
 228
 229 #if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
 230   void * operator new (size_t size, wxChar * fileName = NULL, int lineNum = 0);
 231 #  if defined(__VISAGECPP__)
 232 #    if __DEBUG_ALLOC__
 233        void operator delete (void * buf,const char * _fname, size_t _line);
 234 #    endif  //__DEBUG_ALLOC__
 235 #  else // Everybody else
 236     void operator delete (void * buf);
 237 #  endif // end of VISAGECPP
 238
 239 // VC++ 6.0
 240 #  if defined(__VISUALC__) && (__VISUALC__ >= 1200)
 241     void operator delete(void *buf, wxChar*, int);
 242 #  endif
 243
 244     // Causes problems for VC++
 245 #  if wxUSE_ARRAY_MEMORY_OPERATORS && !defined(__VISUALC__) && !defined( __MWERKS__)
 246     void * operator new[] (size_t size, wxChar * fileName = NULL, int lineNum = 0);
 247     void operator delete[] (void * buf);
 248 #  endif
 249
 250 #  ifdef __MWERKS__
 251     void * operator new[] (size_t size, wxChar * fileName , int lineNum = 0);
 252     void * operator new[] (size_t size) { return operator new[] ( size , NULL , 0 ) ; }
 253     void operator delete[] (void * buf);
 254 #  endif
 255
 256 #endif // Debug & memory tracing
 257
 258 #if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT)
 259   virtual void Dump(wxSTD ostream& str);
 260 #endif
 261
 262 #if wxUSE_SERIAL
 263   virtual void StoreObject( wxObjectOutputStream &stream );
 264   virtual void LoadObject( wxObjectInputStream &stream );
 265 #endif
 266
 267   // make a 'clone' of the object
 268   void Ref(const wxObject& clone);
 269
 270   // destroy a reference
 271   void UnRef(void);
 272
 273   inline wxObjectRefData *GetRefData(void) const { return m_refData; }
 274   inline void SetRefData(wxObjectRefData *data) { m_refData = data; }
 275
 276 protected:
 277   wxObjectRefData*      m_refData;
 278 #if wxUSE_SERIAL
 279   wxObject_Serialize*   m_serialObj;
 280 #endif
 281 };
 282
 283 /*
 284  * wxObjectData
 285  */
 286
 287 class WXDLLEXPORT wxObjectRefData {
 288
 289     friend class wxObject;
 290
 291 public:
 292     wxObjectRefData(void);
 293     virtual ~wxObjectRefData(void);
 294
 295     inline int GetRefCount(void) const { return m_count; }
 296 private:
 297     int m_count;
 298 };
 299
 300 #ifdef __WXDEBUG__
 301 #ifndef WXDEBUG_NEW
 302 #define WXDEBUG_NEW new(__TFILE__,__LINE__)
 303 #endif
 304 #else
 305 #define WXDEBUG_NEW new
 306 #endif
 307
 308 // Redefine new to be the debugging version. This doesn't
 309 // work with all compilers, in which case you need to
 310 // use WXDEBUG_NEW explicitly if you wish to use the debugging version.
 311
 312 #if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
 313 #define new new(__TFILE__,__LINE__)
 314 #endif
 315
 316 #endif
 317     // _WX_OBJECTH__
 318
 319