src/common/object.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        object.cpp
   3 // Purpose:     wxObject implementation
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "object.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/hash.h"
  25     #if wxUSE_SERIAL
  26         #include "wx/objstrm.h"
  27         #include "wx/serbase.h"
  28
  29         // for error messages
  30         #include "wx/log.h"
  31         #include "wx/intl.h"
  32     #endif // wxUSE_SERIAL
  33 #endif // WX_PRECOMP
  34
  35 #include <string.h>
  36 #include <assert.h>
  37
  38 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
  39 #include "wx/memory.h"
  40 #endif
  41
  42 #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
  43     // for wxObject::Dump
  44     #include "wx/ioswrap.h"
  45     #if defined(__VISAGECPP__)
  46     // help with VA debugging
  47         #define DEBUG_PRINTF(NAME)   { static int raz=0; \
  48           printf( #NAME " %i\n",raz); fflush(stdout);       \
  49            raz++;                                        \
  50          }
  51     #else
  52         #define DEBUG_PRINTF(NAME)
  53     #endif
  54 #endif
  55
  56 wxClassInfo wxObject::sm_classwxObject((wxChar *) wxT("wxObject"), (wxChar *) NULL, (wxChar *) NULL, (int ) sizeof(wxObject), (wxObjectConstructorFn) NULL);
  57 wxClassInfo* wxClassInfo::sm_first = (wxClassInfo *) NULL;
  58 wxHashTable* wxClassInfo::sm_classTable = (wxHashTable*) NULL;
  59
  60 #if defined(__WXDEBUG__) && defined(__VISAGECPP__)
  61   int wxObject::N = 0;  // total number of objects
  62   int wxObject::Nid = 0;// object serial counter
  63 #endif // __WXDEBUG__
  64
  65 // These are here so we can avoid 'always true/false' warnings
  66 // by referring to these instead of TRUE/FALSE
  67 const bool wxTrue = TRUE;
  68 const bool wxFalse = FALSE;
  69
  70 /*
  71  * wxWindows root object.
  72  */
  73
  74 wxObject::wxObject()
  75 {
  76     m_refData = (wxObjectRefData *) NULL;
  77 #if wxUSE_SERIAL
  78     m_serialObj = (wxObject_Serialize *)NULL;
  79 #endif
  80 #if defined(__WXDEBUG__) && defined(__VISAGECPP__)
  81     id = Nid++;
  82     N++;
  83 //  {  printf("wxObject %i/%i \t",id,N);
  84 //  }
  85 #endif
  86 }
  87
  88 wxObject::~wxObject()
  89 {
  90     UnRef();
  91 #if wxUSE_SERIAL
  92     if (m_serialObj)
  93         delete m_serialObj;
  94 #endif
  95 #if defined(__WXDEBUG__) && defined(__VISAGECPP__)
  96      N--;
  97 //  {  printf("~wxObject %i/%i \t",id,N);
  98 //  }
  99 #endif  //__WXDEBUG__
 100 }
 101
 102 /*
 103  * Is this object a kind of (a subclass of) 'info'?
 104  * E.g. is wxWindow a kind of wxObject?
 105  * Go from this class to superclass, taking into account
 106  * two possible base classes.
 107  */
 108
 109 bool wxObject::IsKindOf(wxClassInfo *info) const
 110 {
 111     wxClassInfo *thisInfo = GetClassInfo();
 112     if (thisInfo)
 113         return thisInfo->IsKindOf(info);
 114     else
 115         return FALSE;
 116 }
 117
 118 wxObject *wxObject::Clone() const
 119 {
 120     wxObject *object = GetClassInfo()->CreateObject();
 121     CopyObject(*object);
 122     return object;
 123 }
 124
 125 #ifdef __WXDEBUG__
 126 void wxObject::CopyObject(wxObject& object_dest) const
 127 #else // !Debug
 128 void wxObject::CopyObject(wxObject& WXUNUSED(object_dest)) const
 129 #endif // Debug/!Debug
 130 {
 131     wxASSERT(object_dest.GetClassInfo()->IsKindOf(GetClassInfo()));
 132 }
 133
 134 #if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT)
 135 void wxObject::Dump(ostream& str)
 136 {
 137     if (GetClassInfo() && GetClassInfo()->GetClassName())
 138         str << GetClassInfo()->GetClassName();
 139     else
 140         str << "unknown object class";
 141 }
 142 #endif
 143
 144 #if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
 145
 146 #ifdef new
 147 #undef new
 148 #endif
 149
 150 void *wxObject::operator new (size_t size, wxChar * fileName, int lineNum)
 151 {
 152     return wxDebugAlloc(size, fileName, lineNum, TRUE);
 153 }
 154
 155 #if defined(__VISAGECPP__)
 156 #  if __DEBUG_ALLOC__
 157 void wxObject::operator delete (void * buf,const char * _fname, size_t _line)
 158 {
 159     wxDebugFree(buf);
 160 }
 161 #  endif  //__DEBUG_ALLOC__
 162 #else
 163 void wxObject::operator delete (void * buf)
 164 {
 165     wxDebugFree(buf);
 166 }
 167 #endif // __VISAGECPP__
 168
 169 // VC++ 6.0
 170 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
 171 void wxObject::operator delete(void* pData, wxChar* /* fileName */, int /* lineNum */)
 172 {
 173     ::operator delete(pData);
 174 }
 175 #endif
 176
 177 // Cause problems for VC++ - crashes
 178 #if (!defined(__VISUALC__) && wxUSE_ARRAY_MEMORY_OPERATORS ) || defined(__MWERKS__)
 179 void * wxObject::operator new[] (size_t size, wxChar * fileName, int lineNum)
 180 {
 181     return wxDebugAlloc(size, fileName, lineNum, TRUE, TRUE);
 182 }
 183
 184 void wxObject::operator delete[] (void * buf)
 185 {
 186     wxDebugFree(buf, TRUE);
 187 }
 188 #endif
 189
 190 #endif
 191
 192 /*
 193  * Class info: provides run-time class type information.
 194  */
 195
 196 wxClassInfo::wxClassInfo(const wxChar *cName,
 197                          const wxChar *baseName1,
 198                          const wxChar *baseName2,
 199                          int sz,
 200                          wxObjectConstructorFn constr)
 201 {
 202     m_className = cName;
 203     m_baseClassName1 = baseName1;
 204     m_baseClassName2 = baseName2;
 205
 206     m_objectSize = sz;
 207     m_objectConstructor = constr;
 208
 209     m_next = sm_first;
 210     sm_first = this;
 211
 212     m_baseInfo1 = (wxClassInfo *) NULL;
 213     m_baseInfo2 = (wxClassInfo *) NULL;
 214 }
 215
 216 wxObject *wxClassInfo::CreateObject()
 217 {
 218     if (m_objectConstructor)
 219         return (wxObject *)(*m_objectConstructor)();
 220     else
 221         return (wxObject *) NULL;
 222 }
 223
 224 wxClassInfo *wxClassInfo::FindClass(const wxChar *c)
 225 {
 226     wxClassInfo *p = sm_first;
 227     while (p)
 228     {
 229         if ( wxStrcmp(p->GetClassName(), c) == 0 )
 230             break;
 231
 232         p = p->m_next;
 233     }
 234
 235     return p;
 236 }
 237
 238 // Climb upwards through inheritance hierarchy.
 239 // Dual inheritance is catered for.
 240 bool wxClassInfo::IsKindOf(const wxClassInfo *info) const
 241 {
 242     if (info == NULL)
 243         return FALSE;
 244
 245     if (this == info)
 246         return TRUE;
 247
 248     if (m_baseInfo1)
 249         if (m_baseInfo1->IsKindOf(info))
 250             return TRUE;
 251
 252     if (m_baseInfo2)
 253         return m_baseInfo2->IsKindOf(info);
 254
 255     return FALSE;
 256 }
 257
 258 // Set pointers to base class(es) to speed up IsKindOf
 259 void wxClassInfo::InitializeClasses()
 260 {
 261     // using IMPLEMENT_DYNAMIC_CLASS() macro twice (which may happen if you
 262     // link any object module twice mistakenly) will break this function
 263     // because it will enter an infinite loop and eventually die with "out of
 264     // memory" - as this is quite hard to detect if you're unaware of this,
 265     // try to do some checks here
 266 #ifdef __WXDEBUG__
 267     // more classes than we'll ever have
 268     static const size_t nMaxClasses = 10000;
 269     size_t nClass = 0;
 270 #endif // Debug
 271
 272     wxClassInfo::sm_classTable = new wxHashTable(wxKEY_STRING);
 273
 274     // Index all class infos by their class name
 275     wxClassInfo *info = sm_first;
 276     while (info)
 277     {
 278         if (info->m_className)
 279         {
 280             wxASSERT_MSG( ++nClass < nMaxClasses,
 281                           _T("an infinite loop detected - have you used IMPLEMENT_DYNAMIC_CLASS() twice (may be by linking some object module(s) twice)?") );
 282
 283             sm_classTable->Put(info->m_className, (wxObject *)info);
 284         }
 285
 286         info = info->m_next;
 287     }
 288
 289     // Set base pointers for each wxClassInfo
 290     info = sm_first;
 291     while (info)
 292     {
 293         if (info->GetBaseClassName1())
 294             info->m_baseInfo1 = (wxClassInfo *)sm_classTable->Get(info->GetBaseClassName1());
 295         if (info->GetBaseClassName2())
 296             info->m_baseInfo2 = (wxClassInfo *)sm_classTable->Get(info->GetBaseClassName2());
 297         info = info->m_next;
 298     }
 299 }
 300
 301 void wxClassInfo::CleanUpClasses()
 302 {
 303     delete wxClassInfo::sm_classTable;
 304     wxClassInfo::sm_classTable = NULL;
 305 }
 306
 307 wxObject *wxCreateDynamicObject(const wxChar *name)
 308 {
 309 #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
 310  DEBUG_PRINTF(wxObject *wxCreateDynamicObject)
 311 #endif
 312
 313     if (wxClassInfo::sm_classTable)
 314     {
 315         wxClassInfo *info = (wxClassInfo *)wxClassInfo::sm_classTable->Get(name);
 316         if (!info)
 317             return (wxObject *)NULL;
 318
 319         return info->CreateObject();
 320     }
 321     else
 322     {
 323         wxClassInfo *info = wxClassInfo::sm_first;
 324         while (info)
 325         {
 326             if (info->m_className && wxStrcmp(info->m_className, name) == 0)
 327                 return info->CreateObject();
 328             info = info->m_next;
 329         }
 330         return (wxObject*) NULL;
 331     }
 332 }
 333
 334 #if wxUSE_SERIAL
 335
 336 #include "wx/serbase.h"
 337 #include "wx/dynlib.h"
 338
 339 wxObject* wxCreateStoredObject( wxInputStream &stream )
 340 {
 341     wxObjectInputStream obj_s(stream);
 342     return obj_s.LoadObject();
 343 };
 344
 345 void wxObject::StoreObject( wxObjectOutputStream& stream )
 346 {
 347 #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
 348  DEBUG_PRINTF(wxObject::StoreObject)
 349 #endif
 350
 351     wxString obj_name = wxString(GetClassInfo()->GetClassName()) + "_Serialize";
 352     wxLibrary *lib = wxTheLibraries.LoadLibrary("wxserial");
 353
 354     if (!lib) {
 355         wxLogError(_("Can't load wxSerial dynamic library."));
 356         return;
 357     }
 358     if (!m_serialObj) {
 359         m_serialObj = (WXSERIAL(wxObject) *)lib->CreateObject( obj_name );
 360
 361         if (!m_serialObj) {
 362             wxLogError(_("Can't find the serialization object '%s' "
 363                         "for the object '%s'."),
 364                     obj_name.c_str(),
 365                     GetClassInfo()->GetClassName());
 366             return;
 367         }
 368         m_serialObj->SetObject(this);
 369     }
 370
 371     m_serialObj->StoreObject(stream);
 372 }
 373
 374 void wxObject::LoadObject( wxObjectInputStream& stream )
 375 {
 376 #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
 377  DEBUG_PRINTF(wxObject::LoadObject)
 378 #endif
 379
 380     wxString obj_name = wxString(GetClassInfo()->GetClassName()) + "_Serialize";
 381     wxLibrary *lib = wxTheLibraries.LoadLibrary("wxserial");
 382
 383     if (!m_serialObj) {
 384         m_serialObj = (WXSERIAL(wxObject) *)lib->CreateObject( obj_name );
 385
 386         if (!m_serialObj) {
 387             wxLogError(_("Can't find the serialization object '%s' "
 388                         "for the object '%s'."),
 389                     obj_name.c_str(),
 390                     GetClassInfo()->GetClassName());
 391             return;
 392         }
 393         m_serialObj->SetObject(this);
 394     }
 395
 396     m_serialObj->LoadObject(stream);
 397 }
 398
 399 #endif // wxUSE_SERIAL
 400
 401 /*
 402  * wxObject: cloning of objects
 403  */
 404
 405 void wxObject::Ref(const wxObject& clone)
 406 {
 407 #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
 408  DEBUG_PRINTF(wxObject::Ref)
 409 #endif
 410      // delete reference to old data
 411     UnRef();
 412     // reference new data
 413     if (clone.m_refData) {
 414         m_refData = clone.m_refData;
 415         ++(m_refData->m_count);
 416     }
 417 }
 418
 419 void wxObject::UnRef()
 420 {
 421     if ( m_refData )
 422     {
 423         wxASSERT_MSG( m_refData->m_count > 0, _T("invalid ref data count") );
 424
 425         if ( !--m_refData->m_count )
 426             delete m_refData;
 427         m_refData = (wxObjectRefData *) NULL;
 428     }
 429 }
 430
 431 /*
 432  * wxObjectData
 433  */
 434
 435 wxObjectRefData::wxObjectRefData(void) : m_count(1)
 436 {
 437 }
 438
 439 wxObjectRefData::~wxObjectRefData()
 440 {
 441 }