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 #endif
  46
  47 #if !USE_SHARED_LIBRARY
  48 wxClassInfo wxObject::sm_classwxObject((wxChar *) wxT("wxObject"), (wxChar *) NULL, (wxChar *) NULL, (int ) sizeof(wxObject), (wxObjectConstructorFn) NULL);
  49 wxClassInfo* wxClassInfo::sm_first = (wxClassInfo *) NULL;
  50 wxHashTable* wxClassInfo::sm_classTable = (wxHashTable*) NULL;
  51 #endif
  52
  53 /*
  54  * wxWindows root object.
  55  */
  56
  57 wxObject::wxObject()
  58 {
  59     m_refData = (wxObjectRefData *) NULL;
  60 #if wxUSE_SERIAL
  61     m_serialObj = (wxObject_Serialize *)NULL;
  62 #endif
  63 }
  64
  65 wxObject::~wxObject()
  66 {
  67     UnRef();
  68 #if wxUSE_SERIAL
  69     if (m_serialObj)
  70         delete m_serialObj;
  71 #endif
  72 }
  73
  74 /*
  75  * Is this object a kind of (a subclass of) 'info'?
  76  * E.g. is wxWindow a kind of wxObject?
  77  * Go from this class to superclass, taking into account
  78  * two possible base classes.
  79  */
  80
  81 bool wxObject::IsKindOf(wxClassInfo *info) const
  82 {
  83     wxClassInfo *thisInfo = GetClassInfo();
  84     if (thisInfo)
  85         return thisInfo->IsKindOf(info);
  86     else
  87         return FALSE;
  88 }
  89
  90 wxObject *wxObject::Clone() const
  91 {
  92     wxObject *object = GetClassInfo()->CreateObject();
  93     CopyObject(*object);
  94     return object;
  95 }
  96
  97 #ifdef __WXDEBUG__
  98 void wxObject::CopyObject(wxObject& object_dest) const
  99 #else // !Debug
 100 void wxObject::CopyObject(wxObject& WXUNUSED(object_dest)) const
 101 #endif // Debug/!Debug
 102 {
 103     wxASSERT(object_dest.GetClassInfo()->IsKindOf(GetClassInfo()));
 104 }
 105
 106 #if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT)
 107 void wxObject::Dump(ostream& str)
 108 {
 109     if (GetClassInfo() && GetClassInfo()->GetClassName())
 110         str << GetClassInfo()->GetClassName();
 111     else
 112         str << "unknown object class";
 113 }
 114 #endif
 115
 116 #if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
 117
 118 #ifdef new
 119 #undef new
 120 #endif
 121
 122 void *wxObject::operator new (size_t size, wxChar * fileName, int lineNum)
 123 {
 124     return wxDebugAlloc(size, fileName, lineNum, TRUE);
 125 }
 126
 127 void wxObject::operator delete (void * buf)
 128 {
 129     wxDebugFree(buf);
 130 }
 131
 132 // VC++ 6.0
 133 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
 134 void wxObject::operator delete(void* pData, char* /* fileName */, int /* lineNum */)
 135 {
 136     ::operator delete(pData);
 137 }
 138 #endif
 139
 140 // Cause problems for VC++ - crashes
 141 #if (!defined(__VISUALC__) && wxUSE_ARRAY_MEMORY_OPERATORS ) || defined(__MWERKS__)
 142 void * wxObject::operator new[] (size_t size, wxChar * fileName, int lineNum)
 143 {
 144     return wxDebugAlloc(size, fileName, lineNum, TRUE, TRUE);
 145 }
 146
 147 void wxObject::operator delete[] (void * buf)
 148 {
 149     wxDebugFree(buf, TRUE);
 150 }
 151 #endif
 152
 153 #endif
 154
 155 /*
 156  * Class info: provides run-time class type information.
 157  */
 158
 159 wxClassInfo::wxClassInfo(wxChar *cName, wxChar *baseName1, wxChar *baseName2, int sz, wxObjectConstructorFn constr)
 160 {
 161     m_className = cName;
 162     m_baseClassName1 = baseName1;
 163     m_baseClassName2 = baseName2;
 164
 165     m_objectSize = sz;
 166     m_objectConstructor = constr;
 167
 168     m_next = sm_first;
 169     sm_first = this;
 170
 171     m_baseInfo1 = (wxClassInfo *) NULL;
 172     m_baseInfo2 = (wxClassInfo *) NULL;
 173 }
 174
 175 wxObject *wxClassInfo::CreateObject()
 176 {
 177     if (m_objectConstructor)
 178         return (wxObject *)(*m_objectConstructor)();
 179     else
 180         return (wxObject *) NULL;
 181 }
 182
 183 wxClassInfo *wxClassInfo::FindClass(wxChar *c)
 184 {
 185     wxClassInfo *p = sm_first;
 186     while (p)
 187     {
 188         if (p && p->GetClassName() && wxStrcmp(p->GetClassName(), c) == 0)
 189             return p;
 190         p = p->m_next;
 191     }
 192     return (wxClassInfo *) NULL;
 193 }
 194
 195 // Climb upwards through inheritance hierarchy.
 196 // Dual inheritance is catered for.
 197 bool wxClassInfo::IsKindOf(wxClassInfo *info) const
 198 {
 199     if (info == NULL)
 200         return FALSE;
 201
 202     // For some reason, when making/using a DLL, static data has to be included
 203     // in both the DLL and the application. This can lead to duplicate
 204     // wxClassInfo objects, so we have to test the name instead of the pointers.
 205     // PROBABLY NO LONGER TRUE now I've done DLL creation right.
 206     /*
 207 #if WXMAKINGDLL
 208 if (GetClassName() && info->GetClassName() && (wxStrcmp(GetClassName(), info->GetClassName()) == 0))
 209 return TRUE;
 210 #else
 211      */
 212     if (this == info)
 213         return TRUE;
 214
 215     if (m_baseInfo1)
 216         if (m_baseInfo1->IsKindOf(info))
 217             return TRUE;
 218
 219     if (m_baseInfo2)
 220         return m_baseInfo2->IsKindOf(info);
 221
 222     return FALSE;
 223 }
 224
 225 // Set pointers to base class(es) to speed up IsKindOf
 226 void wxClassInfo::InitializeClasses()
 227 {
 228     // using IMPLEMENT_DYNAMIC_CLASS() macro twice (which may happen if you
 229     // link any object module twice mistakenly) will break this function
 230     // because it will enter an infinite loop and eventually die with "out of
 231     // memory" - as this is quite hard to detect if you're unaware of this,
 232     // try to do some checks here
 233 #ifdef __WXDEBUG__
 234     // more classes than we'll ever have
 235     static const size_t nMaxClasses = 10000;
 236     size_t nClass = 0;
 237 #endif // Debug
 238
 239     wxClassInfo::sm_classTable = new wxHashTable(wxKEY_STRING);
 240
 241     // Index all class infos by their class name
 242     wxClassInfo *info = sm_first;
 243     while (info)
 244     {
 245         if (info->m_className)
 246         {
 247             wxASSERT_MSG( ++nClass < nMaxClasses,
 248                           _T("an infinite loop detected - have you used "
 249                             "IMPLEMENT_DYNAMIC_CLASS() twice (may be by "
 250                             "linking some object module(s) twice)?") );
 251
 252             sm_classTable->Put(info->m_className, (wxObject *)info);
 253         }
 254
 255         info = info->m_next;
 256     }
 257
 258     // Set base pointers for each wxClassInfo
 259     info = sm_first;
 260     while (info)
 261     {
 262         if (info->GetBaseClassName1())
 263             info->m_baseInfo1 = (wxClassInfo *)sm_classTable->Get(info->GetBaseClassName1());
 264         if (info->GetBaseClassName2())
 265             info->m_baseInfo2 = (wxClassInfo *)sm_classTable->Get(info->GetBaseClassName2());
 266         info = info->m_next;
 267     }
 268 }
 269
 270 void wxClassInfo::CleanUpClasses()
 271 {
 272     delete wxClassInfo::sm_classTable;
 273     wxClassInfo::sm_classTable = NULL;
 274 }
 275
 276 wxObject *wxCreateDynamicObject(const wxChar *name)
 277 {
 278     if (wxClassInfo::sm_classTable)
 279     {
 280         wxClassInfo *info = (wxClassInfo *)wxClassInfo::sm_classTable->Get(name);
 281         if (!info)
 282             return (wxObject *)NULL;
 283
 284         return info->CreateObject();
 285     }
 286     else
 287     {
 288         wxClassInfo *info = wxClassInfo::sm_first;
 289         while (info)
 290         {
 291             if (info->m_className && wxStrcmp(info->m_className, name) == 0)
 292                 return info->CreateObject();
 293             info = info->m_next;
 294         }
 295         return (wxObject*) NULL;
 296     }
 297 }
 298
 299 #if wxUSE_SERIAL
 300
 301 #include "wx/serbase.h"
 302 #include "wx/dynlib.h"
 303 #include "wx/msgdlg.h"
 304
 305 wxObject* wxCreateStoredObject( wxInputStream &stream )
 306 {
 307     wxObjectInputStream obj_s(stream);
 308     return obj_s.LoadObject();
 309 };
 310
 311 void wxObject::StoreObject( wxObjectOutputStream& stream )
 312 {
 313     wxString obj_name = wxString(GetClassInfo()->GetClassName()) + "_Serialize";
 314     wxLibrary *lib = wxTheLibraries.LoadLibrary("wxserial");
 315
 316     if (!lib) {
 317         wxLogError(_("Can't load wxSerial dynamic library."));
 318         return;
 319     }
 320     if (!m_serialObj) {
 321         m_serialObj = (WXSERIAL(wxObject) *)lib->CreateObject( obj_name );
 322
 323         if (!m_serialObj) {
 324             wxLogError(_("Can't find the serialization object '%s' "
 325                         "for the object '%s'."),
 326                     obj_name.c_str(),
 327                     GetClassInfo()->GetClassName());
 328             return;
 329         }
 330         m_serialObj->SetObject(this);
 331     }
 332
 333     m_serialObj->StoreObject(stream);
 334 }
 335
 336 void wxObject::LoadObject( wxObjectInputStream& stream )
 337 {
 338     wxString obj_name = wxString(GetClassInfo()->GetClassName()) + "_Serialize";
 339     wxLibrary *lib = wxTheLibraries.LoadLibrary("wxserial");
 340
 341     if (!m_serialObj) {
 342         m_serialObj = (WXSERIAL(wxObject) *)lib->CreateObject( obj_name );
 343
 344         if (!m_serialObj) {
 345             wxLogError(_("Can't find the serialization object '%s' "
 346                         "for the object '%s'."),
 347                     obj_name.c_str(),
 348                     GetClassInfo()->GetClassName());
 349             return;
 350         }
 351         m_serialObj->SetObject(this);
 352     }
 353
 354     m_serialObj->LoadObject(stream);
 355 }
 356
 357 #endif // wxUSE_SERIAL
 358
 359 /*
 360  * wxObject: cloning of objects
 361  */
 362
 363 void wxObject::Ref(const wxObject& clone)
 364 {
 365     // delete reference to old data
 366     UnRef();
 367     // reference new data
 368     if (clone.m_refData) {
 369         m_refData = clone.m_refData;
 370         ++(m_refData->m_count);
 371     }
 372 }
 373
 374 void wxObject::UnRef()
 375 {
 376     if ( m_refData )
 377     {
 378         wxASSERT_MSG( m_refData->m_count > 0, _T("invalid ref data count") );
 379
 380         if ( !--m_refData->m_count )
 381             delete m_refData;
 382
 383         m_refData = (wxObjectRefData *) NULL;
 384     }
 385 }
 386
 387 /*
 388  * wxObjectData
 389  */
 390
 391 wxObjectRefData::wxObjectRefData(void) : m_count(1)
 392 {
 393 }
 394
 395 wxObjectRefData::~wxObjectRefData()
 396 {
 397 }
 398
 399 // These are here so we can avoid 'always true/false' warnings
 400 // by referring to these instead of TRUE/FALSE
 401 const bool wxTrue = TRUE;
 402 const bool wxFalse = FALSE;