#define wxUSE_EXTENDED_RTTI 0
#endif
-#define DECLARE_CLASS_INFO_ITERATORS() \
+#define wxDECLARE_CLASS_INFO_ITERATORS() \
class WXDLLIMPEXP_BASE const_iterator \
{ \
typedef wxHashTable_Node Node; \
}; \
\
static const_iterator begin_classinfo(); \
- static const_iterator end_classinfo();
+ static const_iterator end_classinfo()
#if wxUSE_EXTENDED_RTTI
#include "wx/xti.h"
class WXDLLIMPEXP_FWD_BASE wxHashTable;
class WXDLLIMPEXP_FWD_BASE wxObject;
class WXDLLIMPEXP_FWD_BASE wxPluginLibrary;
-class WXDLLIMPEXP_FWD_BASE wxObjectRefData;
class WXDLLIMPEXP_FWD_BASE wxHashTable_Node;
// ----------------------------------------------------------------------------
( m_baseInfo2 && m_baseInfo2->IsKindOf(info) ) );
}
- DECLARE_CLASS_INFO_ITERATORS()
+ wxDECLARE_CLASS_INFO_ITERATORS();
+
private:
const wxChar *m_className;
int m_objectSize;
void Register();
void Unregister();
- DECLARE_NO_COPY_CLASS(wxClassInfo)
+ wxDECLARE_NO_COPY_CLASS(wxClassInfo);
};
WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxString& name);
// Dynamic class macros
// ----------------------------------------------------------------------------
-#define DECLARE_ABSTRACT_CLASS(name) \
+#define wxDECLARE_ABSTRACT_CLASS(name) \
public: \
static wxClassInfo ms_classInfo; \
- virtual wxClassInfo *GetClassInfo() const;
+ virtual wxClassInfo *GetClassInfo() const
-#define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name) \
- DECLARE_NO_ASSIGN_CLASS(name) \
- DECLARE_DYNAMIC_CLASS(name)
+#define wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(name) \
+ wxDECLARE_NO_ASSIGN_CLASS(name); \
+ wxDECLARE_DYNAMIC_CLASS(name)
-#define DECLARE_DYNAMIC_CLASS_NO_COPY(name) \
- DECLARE_NO_COPY_CLASS(name) \
- DECLARE_DYNAMIC_CLASS(name)
+#define wxDECLARE_DYNAMIC_CLASS_NO_COPY(name) \
+ wxDECLARE_NO_COPY_CLASS(name); \
+ wxDECLARE_DYNAMIC_CLASS(name)
-#define DECLARE_DYNAMIC_CLASS(name) \
- DECLARE_ABSTRACT_CLASS(name) \
- static wxObject* wxCreateObject();
+#define wxDECLARE_DYNAMIC_CLASS(name) \
+ wxDECLARE_ABSTRACT_CLASS(name); \
+ static wxObject* wxCreateObject()
-#define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
+#define wxDECLARE_CLASS(name) \
+ wxDECLARE_DYNAMIC_CLASS(name)
// common part of the macros below
&basename::ms_classInfo, \
baseclsinfo2, \
(int) sizeof(name), \
- (wxObjectConstructorFn) func); \
+ func); \
\
wxClassInfo *name::GetClassInfo() const \
{ return &name::ms_classInfo; }
// -----------------------------------
// Single inheritance with one base class
-#define IMPLEMENT_DYNAMIC_CLASS(name, basename) \
+#define wxIMPLEMENT_DYNAMIC_CLASS(name, basename) \
wxIMPLEMENT_CLASS_COMMON1(name, basename, name::wxCreateObject) \
wxObject* name::wxCreateObject() \
{ return new name; }
// Multiple inheritance with two base classes
-#define IMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) \
+#define wxIMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) \
wxIMPLEMENT_CLASS_COMMON2(name, basename1, basename2, \
name::wxCreateObject) \
wxObject* name::wxCreateObject() \
// -----------------------------------
// Single inheritance with one base class
-
-#define IMPLEMENT_ABSTRACT_CLASS(name, basename) \
+#define wxIMPLEMENT_ABSTRACT_CLASS(name, basename) \
wxIMPLEMENT_CLASS_COMMON1(name, basename, NULL)
// Multiple inheritance with two base classes
-
-#define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
+#define wxIMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
wxIMPLEMENT_CLASS_COMMON2(name, basename1, basename2, NULL)
-#define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
-#define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
+#define wxIMPLEMENT_CLASS(name, basename) \
+ wxIMPLEMENT_ABSTRACT_CLASS(name, basename)
+
+#define wxIMPLEMENT_CLASS2(name, basename1, basename2) \
+ IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2)
#endif // !wxUSE_EXTENDED_RTTI
name##PluginSentinel(); \
~name##PluginSentinel(); \
}; \
-name##PluginSentinel m_pluginsentinel;
+name##PluginSentinel m_pluginsentinel
#define _IMPLEMENT_DL_SENTINEL(name) \
const wxString name::name##PluginSentinel::sm_className(#name); \
#endif // wxUSE_NESTED_CLASSES
-#define DECLARE_PLUGGABLE_CLASS(name) \
- DECLARE_DYNAMIC_CLASS(name) _DECLARE_DL_SENTINEL(name, WXDLLIMPEXP_CORE)
-#define DECLARE_ABSTRACT_PLUGGABLE_CLASS(name) \
- DECLARE_ABSTRACT_CLASS(name) _DECLARE_DL_SENTINEL(name, WXDLLIMPEXP_CORE)
-
-#define DECLARE_USER_EXPORTED_PLUGGABLE_CLASS(name, usergoo) \
- DECLARE_DYNAMIC_CLASS(name) _DECLARE_DL_SENTINEL(name, usergoo)
-#define DECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(name, usergoo) \
- DECLARE_ABSTRACT_CLASS(name) _DECLARE_DL_SENTINEL(name, usergoo)
-
-#define IMPLEMENT_PLUGGABLE_CLASS(name, basename) \
- IMPLEMENT_DYNAMIC_CLASS(name, basename) _IMPLEMENT_DL_SENTINEL(name)
-#define IMPLEMENT_PLUGGABLE_CLASS2(name, basename1, basename2) \
- IMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) _IMPLEMENT_DL_SENTINEL(name)
-#define IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(name, basename) \
- IMPLEMENT_ABSTRACT_CLASS(name, basename) _IMPLEMENT_DL_SENTINEL(name)
-#define IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2) \
- IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) _IMPLEMENT_DL_SENTINEL(name)
-
-#define IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(name, basename) \
- IMPLEMENT_PLUGGABLE_CLASS(name, basename)
-#define IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(name, basename1, basename2) \
- IMPLEMENT_PLUGGABLE_CLASS2(name, basename1, basename2)
-#define IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(name, basename) \
- IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(name, basename)
-#define IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2) \
- IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2)
-
-#define CLASSINFO(name) (&name::ms_classInfo)
+#define wxDECLARE_PLUGGABLE_CLASS(name) \
+ wxDECLARE_DYNAMIC_CLASS(name); _DECLARE_DL_SENTINEL(name, WXDLLIMPEXP_CORE)
+#define wxDECLARE_ABSTRACT_PLUGGABLE_CLASS(name) \
+ wxDECLARE_ABSTRACT_CLASS(name); _DECLARE_DL_SENTINEL(name, WXDLLIMPEXP_CORE)
+
+#define wxDECLARE_USER_EXPORTED_PLUGGABLE_CLASS(name, usergoo) \
+ wxDECLARE_DYNAMIC_CLASS(name); _DECLARE_DL_SENTINEL(name, usergoo)
+#define wxDECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(name, usergoo) \
+ wxDECLARE_ABSTRACT_CLASS(name); _DECLARE_DL_SENTINEL(name, usergoo)
+
+#define wxIMPLEMENT_PLUGGABLE_CLASS(name, basename) \
+ wxIMPLEMENT_DYNAMIC_CLASS(name, basename) _IMPLEMENT_DL_SENTINEL(name)
+#define wxIMPLEMENT_PLUGGABLE_CLASS2(name, basename1, basename2) \
+ wxIMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) _IMPLEMENT_DL_SENTINEL(name)
+#define wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(name, basename) \
+ wxIMPLEMENT_ABSTRACT_CLASS(name, basename) _IMPLEMENT_DL_SENTINEL(name)
+#define wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2) \
+ wxIMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) _IMPLEMENT_DL_SENTINEL(name)
+
+#define wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(name, basename) \
+ wxIMPLEMENT_PLUGGABLE_CLASS(name, basename)
+#define wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(name, basename1, basename2) \
+ wxIMPLEMENT_PLUGGABLE_CLASS2(name, basename1, basename2)
+#define wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(name, basename) \
+ wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(name, basename)
+#define wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2) \
+ wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(name, basename1, basename2)
+
+#define wxCLASSINFO(name) (&name::ms_classInfo)
#define wxIS_KIND_OF(obj, className) obj->IsKindOf(&className::ms_classInfo)
#define wxDynamicCastThis(className) \
(IsKindOf(&className::ms_classInfo) ? (className *)(this) : (className *)0)
-#ifdef __WXDEBUG__
-inline void* wxCheckCast(void *ptr)
+// FIXME-VC6: dummy argument needed because VC6 doesn't support explicitly
+// choosing the template function to call
+template <class T>
+inline T *wxCheckCast(const void *ptr, T * = NULL)
{
- wxASSERT_MSG( ptr, _T("wxStaticCast() used incorrectly") );
- return ptr;
+ wxASSERT_MSG( wxDynamicCast(ptr, T), "wxStaticCast() used incorrectly" );
+ return const_cast<T *>(static_cast<const T *>(ptr));
}
-#define wxStaticCast(obj, className) \
- ((className *)wxCheckCast(wxDynamicCast(obj, className)))
-#else // !__WXDEBUG__
-#define wxStaticCast(obj, className) \
- const_cast<className *>(static_cast<const className *>(obj))
-
-#endif // __WXDEBUG__
+#define wxStaticCast(obj, className) wxCheckCast((obj), (className *)NULL)
// ----------------------------------------------------------------------------
// set up memory debugging macros
_WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT = void operator delete[] (void* buf, wxChar*, int )
*/
-#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
+#if wxUSE_MEMORY_TRACING
// All compilers get this one
#define _WX_WANT_NEW_SIZET_WXCHAR_INT
#endif // wxUSE_ARRAY_MEMORY_OPERATORS
-#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
+#endif // wxUSE_MEMORY_TRACING
// ----------------------------------------------------------------------------
-// wxObjectRefData: ref counted data meant to be stored in wxObject
+// wxRefCounter: ref counted data "manager"
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_BASE wxObjectRefData
+class WXDLLIMPEXP_BASE wxRefCounter
{
- friend class WXDLLIMPEXP_FWD_BASE wxObject;
-
public:
- wxObjectRefData() : m_count(1) { }
+ wxRefCounter() { m_count = 1; }
int GetRefCount() const { return m_count; }
protected:
// this object should never be destroyed directly but only as a
// result of a DecRef() call:
- virtual ~wxObjectRefData() { }
+ virtual ~wxRefCounter() { }
private:
// our refcount:
int m_count;
};
+// ----------------------------------------------------------------------------
+// wxObjectRefData: ref counted data meant to be stored in wxObject
+// ----------------------------------------------------------------------------
+
+typedef wxRefCounter wxObjectRefData;
+
+
// ----------------------------------------------------------------------------
// wxObjectDataPtr: helper class to avoid memleaks because of missing calls
// to wxObjectRefData::DecRef
class WXDLLIMPEXP_BASE wxObject
{
- DECLARE_ABSTRACT_CLASS(wxObject)
+ wxDECLARE_ABSTRACT_CLASS(wxObject);
public:
wxObject() { m_refData = NULL; }
{
m_refData = other.m_refData;
if (m_refData)
- m_refData->m_count++;
+ m_refData->IncRef();
}
wxObject& operator=(const wxObject& other)
// more debugging macros
// ----------------------------------------------------------------------------
-// Redefine new to be the debugging version. This doesn't work with all
-// compilers, in which case you need to use WXDEBUG_NEW explicitly if you wish
-// to use the debugging version.
-
-#ifdef __WXDEBUG__
+#if wxUSE_DEBUG_NEW_ALWAYS
#define WXDEBUG_NEW new(__TFILE__,__LINE__)
- #if wxUSE_DEBUG_NEW_ALWAYS
- #if wxUSE_GLOBAL_MEMORY_OPERATORS
- #define new WXDEBUG_NEW
- #elif defined(__VISUALC__)
- // Including this file redefines new and allows leak reports to
- // contain line numbers
- #include "wx/msw/msvcrt.h"
- #endif
- #endif // wxUSE_DEBUG_NEW_ALWAYS
-#else // !__WXDEBUG__
- #define WXDEBUG_NEW new
-#endif // __WXDEBUG__/!__WXDEBUG__
+ #if wxUSE_GLOBAL_MEMORY_OPERATORS
+ #define new WXDEBUG_NEW
+ #elif defined(__VISUALC__)
+ // Including this file redefines new and allows leak reports to
+ // contain line numbers
+ #include "wx/msw/msvcrt.h"
+ #endif
+#endif // wxUSE_DEBUG_NEW_ALWAYS
+
+// ----------------------------------------------------------------------------
+// Compatibility macro aliases
+// ----------------------------------------------------------------------------
+
+// deprecated variants _not_ requiring a semicolon after them and without wx prefix.
+// (note that also some wx-prefixed macro do _not_ require a semicolon because
+// it's not always possible to force the compire to require it)
+
+#define DECLARE_CLASS_INFO_ITERATORS() wxDECLARE_CLASS_INFO_ITERATORS();
+#define DECLARE_ABSTRACT_CLASS(n) wxDECLARE_ABSTRACT_CLASS(n);
+#define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(n) wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(n);
+#define DECLARE_DYNAMIC_CLASS_NO_COPY(n) wxDECLARE_DYNAMIC_CLASS_NO_COPY(n);
+#define DECLARE_DYNAMIC_CLASS(n) wxDECLARE_DYNAMIC_CLASS(n);
+#define DECLARE_CLASS(n) wxDECLARE_CLASS(n);
+
+#define IMPLEMENT_DYNAMIC_CLASS(n,b) wxIMPLEMENT_DYNAMIC_CLASS(n,b)
+#define IMPLEMENT_DYNAMIC_CLASS2(n,b1,b2) wxIMPLEMENT_DYNAMIC_CLASS2(n,b1,b2)
+#define IMPLEMENT_ABSTRACT_CLASS(n,b) wxIMPLEMENT_ABSTRACT_CLASS(n,b)
+#define IMPLEMENT_ABSTRACT_CLASS2(n,b1,b2) wxIMPLEMENT_ABSTRACT_CLASS2(n,b1,b2)
+#define IMPLEMENT_CLASS(n,b) wxIMPLEMENT_CLASS(n,b)
+#define IMPLEMENT_CLASS2(n,b1,b2) wxIMPLEMENT_CLASS2(n,b1,b2)
+
+#define DECLARE_PLUGGABLE_CLASS(n) wxDECLARE_PLUGGABLE_CLASS(n);
+#define DECLARE_ABSTRACT_PLUGGABLE_CLASS(n) wxDECLARE_ABSTRACT_PLUGGABLE_CLASS(n);
+#define DECLARE_USER_EXPORTED_PLUGGABLE_CLASS(n,u) wxDECLARE_USER_EXPORTED_PLUGGABLE_CLASS(n,u);
+#define DECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,u) wxDECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,u);
+
+#define IMPLEMENT_PLUGGABLE_CLASS(n,b) wxIMPLEMENT_PLUGGABLE_CLASS(n,b)
+#define IMPLEMENT_PLUGGABLE_CLASS2(n,b,b2) wxIMPLEMENT_PLUGGABLE_CLASS2(n,b,b2)
+#define IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(n,b) wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(n,b)
+#define IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2) wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2)
+#define IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(n,b) wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(n,b)
+#define IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(n,b,b2) wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(n,b,b2)
+#define IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,b) wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,b)
+#define IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2) wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2)
+
+#define CLASSINFO(n) wxCLASSINFO(n)
#endif // _WX_OBJECTH__
projects / wxWidgets.git / blobdiff