void SetItemCount(long count);
wxTextCtrl *EditLabel(long item,
- wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl));
+ wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
wxTextCtrl* GetEditControl() const;
void Edit( long item ) { EditLabel(item); }
// start editing the label of the given item
wxTextCtrl *EditLabel(long item,
- wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl));
+ wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
wxTextCtrl *GetEditControl() const
{
return m_textctrlWrapper ? m_textctrlWrapper->GetText() : NULL;
virtual void ScrollTo(const wxTreeItemId& item);
virtual wxTextCtrl *EditLabel(const wxTreeItemId& item,
- wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
+ wxClassInfo* textCtrlClass = wxCLASSINFO(wxTextCtrl));
virtual wxTextCtrl *GetEditControl() const;
virtual void EndEditLabel(const wxTreeItemId& item,
bool discardChanges = false);
// been before. textCtrlClass parameter allows you to create an edit
// control of arbitrary user-defined class deriving from wxTextCtrl.
wxTextCtrl* EditLabel(const wxTreeItemId& item,
- wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
+ wxClassInfo* textCtrlClass = wxCLASSINFO(wxTextCtrl));
// returns the same pointer as StartEdit() if the item is being edited,
// NULL otherwise (it's assumed that no more than one item may be
// edited simultaneously)
void ClearAll();
// Edit the label
- wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl));
+ wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
// End label editing, optionally cancelling the edit
bool EndEditLabel(bool cancel);
virtual void ScrollTo(const wxTreeItemId& item);
virtual wxTextCtrl *EditLabel(const wxTreeItemId& item,
- wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
+ wxClassInfo* textCtrlClass = wxCLASSINFO(wxTextCtrl));
virtual wxTextCtrl *GetEditControl() const;
virtual void EndEditLabel(const wxTreeItemId& WXUNUSED(item),
bool discardChanges = false)
#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"
( m_baseInfo2 && m_baseInfo2->IsKindOf(info) ) );
}
- DECLARE_CLASS_INFO_ITERATORS()
+ wxDECLARE_CLASS_INFO_ITERATORS();
+
private:
const wxChar *m_className;
int m_objectSize;
// 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
// -----------------------------------
// 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)
class WXDLLIMPEXP_BASE wxObject
{
- DECLARE_ABSTRACT_CLASS(wxObject)
+ wxDECLARE_ABSTRACT_CLASS(wxObject);
public:
wxObject() { m_refData = NULL; }
#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__
// Edit the label
//
wxTextCtrl* EditLabel( long lItem
- ,wxClassInfo* pTextControlClass = CLASSINFO(wxTextCtrl)
+ ,wxClassInfo* pTextControlClass = wxCLASSINFO(wxTextCtrl)
);
//
// interface compatibility, only.
//
wxTextCtrl* EditLabel( const wxTreeItemId& rItem
- ,wxClassInfo* pTextCtrlClass = CLASSINFO(wxTextCtrl)
+ ,wxClassInfo* pTextCtrlClass = wxCLASSINFO(wxTextCtrl)
);
//
void ClearAll();
// Edit the label
- wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl));
+ wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
// End label editing, optionally cancelling the edit
bool EndEditLabel(bool cancel);
bool DeleteAllItems();
// Edit the label (tree must have the focus)
- wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl));
+ wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
// End label editing, optionally cancelling the edit
bool EndEditLabel(bool cancel);
void ClearAll();
// Edit the label
- wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl));
+ wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
// End label editing, optionally cancelling the edit
bool EndEditLabel(bool cancel);
// been before. textCtrlClass parameter allows you to create an edit
// control of arbitrary user-defined class deriving from wxTextCtrl.
wxTextCtrl* EditLabel(const wxTreeItemId& item,
- wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
+ wxClassInfo* textCtrlClass = wxCLASSINFO(wxTextCtrl));
// returns the same pointer as StartEdit() if the item is being edited,
// NULL otherwise (it's assumed that no more than one item may be
// edited simultaneously)
static wxProtoInfo g_proto_##class;
#define IMPLEMENT_PROTOCOL(class, name, serv, host) \
-wxProtoInfo class::g_proto_##class(name, serv, host, CLASSINFO(class)); \
+wxProtoInfo class::g_proto_##class(name, serv, host, wxCLASSINFO(class)); \
bool wxProtocolUse##class = true;
#define USE_PROTOCOL(class) \
#include "wx/control.h"
#include "wx/treebase.h"
-#include "wx/textctrl.h" // wxTextCtrl::ms_classinfo used through CLASSINFO macro
+#include "wx/textctrl.h" // wxTextCtrl::ms_classinfo used through wxCLASSINFO macro
class WXDLLIMPEXP_FWD_CORE wxImageList;
// been before. textCtrlClass parameter allows you to create an edit
// control of arbitrary user-defined class deriving from wxTextCtrl.
virtual wxTextCtrl *EditLabel(const wxTreeItemId& item,
- wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl)) = 0;
+ wxClassInfo* textCtrlClass = wxCLASSINFO(wxTextCtrl)) = 0;
// returns the same pointer as StartEdit() if the item is being edited,
// NULL otherwise (it's assumed that no more than one item may be
// edited simultaneously)
A name that should be unique for a given view.
@param docClassInfo
A pointer to the run-time document class information as returned by
- the CLASSINFO() macro, e.g. CLASSINFO(MyDocumentClass). If this is
+ the wxCLASSINFO() macro, e.g. wxCLASSINFO(MyDocumentClass). If this is
not supplied, you will need to derive a new wxDocTemplate class and
override the CreateDocument() member to return a new document
instance on demand.
@param viewClassInfo
A pointer to the run-time view class information as returned by the
- CLASSINFO() macro, e.g. CLASSINFO(MyViewClass). If this is not
+ wxCLASSINFO() macro, e.g. wxCLASSINFO(MyViewClass). If this is not
supplied, you will need to derive a new wxDocTemplate class and
override the CreateView() member to return a new view instance on
demand.
will be sent which can be vetoed as well.
*/
wxTextCtrl* EditLabel(long item,
- wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl));
+ wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
/**
Finish editing the label.
To define a new kind of module, derive a class from wxModule, override the
wxModule::OnInit and wxModule::OnExit functions, and add the
- DECLARE_DYNAMIC_CLASS and IMPLEMENT_DYNAMIC_CLASS to header and implementation
+ wxDECLARE_DYNAMIC_CLASS and wxIMPLEMENT_DYNAMIC_CLASS to header and implementation
files (which can be the same file).
On initialization, wxWidgets will find all classes derived from wxModule, create
an instance of each, and call each wxModule::OnInit function. On exit, wxWidgets
virtual void OnExit() { wxDDECleanUp(); };
private:
- DECLARE_DYNAMIC_CLASS(wxDDEModule)
+ wxDECLARE_DYNAMIC_CLASS(wxDDEModule);
};
- IMPLEMENT_DYNAMIC_CLASS(wxDDEModule, wxModule)
+ wxIMPLEMENT_DYNAMIC_CLASS(wxDDEModule, wxModule);
// Another module which uses DDE in its OnInit()
class MyModule: public wxModule
{
public:
- MyModule() { AddDependency(CLASSINFO(wxDDEModule)); }
+ MyModule() { AddDependency(wxCLASSINFO(wxDDEModule)); }
virtual bool OnInit() { ... code using DDE ... }
virtual void OnExit() { ... }
private:
- DECLARE_DYNAMIC_CLASS(MyModule)
+ wxDECLARE_DYNAMIC_CLASS(MyModule);
};
- IMPLEMENT_DYNAMIC_CLASS(MyModule, wxModule)
+ wxIMPLEMENT_DYNAMIC_CLASS(MyModule, wxModule);
// Another module which uses DDE in its OnInit()
// but uses a named dependency
virtual void OnExit() { ... }
private:
- DECLARE_DYNAMIC_CLASS(MyModule2)
+ wxDECLARE_DYNAMIC_CLASS(MyModule2)
};
- IMPLEMENT_DYNAMIC_CLASS(MyModule2, wxModule)
+ wxIMPLEMENT_DYNAMIC_CLASS(MyModule2, wxModule)
@endcode
@library{wxbase}
/**
Call this function from the constructor of the derived class.
- @a dep must be the CLASSINFO() of a wxModule-derived class and the
+ @a dep must be the wxCLASSINFO() of a wxModule-derived class and the
corresponding module will be loaded before and unloaded after this module.
@param dep
the class info.
This is useful when a module is declared entirely in a source file and
- there is no header for the declaration of the module needed by CLASSINFO(),
+ there is no header for the declaration of the module needed by wxCLASSINFO(),
however errors are not detected until run-time, instead of compile-time, then.
Note that circular dependencies are detected and result in a fatal error.
wxActiveXContainer* m_pAX;
wxAutomationObject m_PDF;
- DECLARE_DYNAMIC_CLASS(wxPDFMediaBackend)
+ wxDECLARE_DYNAMIC_CLASS(wxPDFMediaBackend)
};
- IMPLEMENT_DYNAMIC_CLASS(wxPDFMediaBackend, wxMediaBackend);
- Put this in one of your existant source files and then create a wxMediaCtrl with
-
- //[this] is the parent window, "myfile.pdf" is the PDF file to open
+ wxIMPLEMENT_DYNAMIC_CLASS(wxPDFMediaBackend, wxMediaBackend);
+
+ // Put this in one of your existant source files and then create a wxMediaCtrl with
wxMediaCtrl* mymediactrl = new wxMediaCtrl(this, "myfile.pdf", wxID_ANY,
wxDefaultPosition, wxSize(300,300),
0, "wxPDFMediaBackend");
+ // [this] is the parent window, "myfile.pdf" is the PDF file to open
@endcode
virtual wxObjectRefData *CreateRefData() const;
virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
- DECLARE_DYNAMIC_CLASS(MyCar)
+ wxDECLARE_DYNAMIC_CLASS(MyCar)
};
#define M_CARDATA ((MyCarRefData *)m_refData)
- IMPLEMENT_DYNAMIC_CLASS(MyCar,wxObject)
+ wxIMPLEMENT_DYNAMIC_CLASS(MyCar, wxObject);
MyCar::MyCar( int price )
{
Example:
@code
- bool tmp = obj->IsKindOf(CLASSINFO(wxFrame));
+ bool tmp = obj->IsKindOf(wxCLASSINFO(wxFrame));
@endcode
@param info
A pointer to a class information object, which may be obtained
- by using the ::CLASSINFO macro.
+ by using the ::wxCLASSINFO macro.
@return @true if the class represented by info is the same class as this
one or is derived from it.
This class stores meta-information about classes.
Instances of this class are not generally defined directly by an application,
- but indirectly through use of macros such as ::DECLARE_DYNAMIC_CLASS and
- ::IMPLEMENT_DYNAMIC_CLASS.
+ but indirectly through use of macros such as ::wxDECLARE_DYNAMIC_CLASS and
+ ::wxIMPLEMENT_DYNAMIC_CLASS.
@library{wxbase}
@category{rtti}
@header{wx/object.h}
*/
-#define CLASSINFO( className )
-
-/**
- Used inside a class declaration to declare that the class should be made
- known to the class hierarchy, but objects of this class cannot be created
- dynamically. The same as DECLARE_ABSTRACT_CLASS().
-
- @header{wx/object.h}
-*/
-#define DECLARE_CLASS( className )
+#define wxCLASSINFO( className )
/**
Used inside a class declaration to declare that the class should be
made known to the class hierarchy, but objects of this class cannot be created
- dynamically. The same as DECLARE_CLASS().
+ dynamically.
@header{wx/object.h}
@code
class wxCommand: public wxObject
{
- DECLARE_ABSTRACT_CLASS(wxCommand)
+ wxDECLARE_ABSTRACT_CLASS(wxCommand);
private:
...
};
@endcode
*/
-#define DECLARE_ABSTRACT_CLASS( className )
+#define wxDECLARE_ABSTRACT_CLASS( className )
/**
Used inside a class declaration to make the class known to wxWidgets RTTI
system and also declare that the objects of this class should be
dynamically creatable from run-time type information. Notice that this
implies that the class should have a default constructor, if this is not
- the case consider using DECLARE_CLASS().
+ the case consider using wxDECLARE_ABSTRACT_CLASS().
@header{wx/object.h}
@code
class wxFrame: public wxWindow
{
- DECLARE_DYNAMIC_CLASS(wxFrame)
+ wxDECLARE_DYNAMIC_CLASS(wxFrame);
private:
const wxString& frameTitle;
};
@endcode
*/
-#define DECLARE_DYNAMIC_CLASS( className )
+#define wxDECLARE_DYNAMIC_CLASS( className )
/**
- Used in a C++ implementation file to complete the declaration of a class
- that has run-time type information. The same as IMPLEMENT_ABSTRACT_CLASS().
-
- @header{wx/object.h}
-*/
-#define IMPLEMENT_CLASS( className, baseClassName )
-
-/**
- Used in a C++ implementation file to complete the declaration of a class
- that has run-time type information and two base classes. The same as
- IMPLEMENT_ABSTRACT_CLASS2().
+ Used inside a class declaration to declare that the class should be made
+ known to the class hierarchy, but objects of this class cannot be created
+ dynamically. The same as wxDECLARE_DYNAMIC_CLASS().
@header{wx/object.h}
*/
-#define IMPLEMENT_CLASS2( className, baseClassName1, baseClassName2 )
+#define wxDECLARE_CLASS( className )
/**
Used in a C++ implementation file to complete the declaration of a class
- that has run-time type information. The same as IMPLEMENT_CLASS().
-
+ that has run-time type information.
+
@header{wx/object.h}
Example:
@code
- IMPLEMENT_ABSTRACT_CLASS(wxCommand, wxObject)
+ wxIMPLEMENT_ABSTRACT_CLASS(wxCommand, wxObject);
wxCommand::wxCommand(void)
{
}
@endcode
*/
-#define IMPLEMENT_ABSTRACT_CLASS( className, baseClassName )
+#define wxIMPLEMENT_ABSTRACT_CLASS( className, baseClassName )
/**
Used in a C++ implementation file to complete the declaration of a class
- that has run-time type information and two base classes. The same as
- IMPLEMENT_CLASS2().
+ that has run-time type information and two base classes.
@header{wx/object.h}
*/
-#define IMPLEMENT_ABSTRACT_CLASS2( className, baseClassName1, baseClassName2 )
+#define wxIMPLEMENT_ABSTRACT_CLASS2( className, baseClassName1, baseClassName2 )
/**
Used in a C++ implementation file to complete the declaration of a class
Example:
@code
- IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
+ wxIMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow);
wxFrame::wxFrame(void)
{
}
@endcode
*/
-#define IMPLEMENT_DYNAMIC_CLASS( className, baseClassName )
+#define wxIMPLEMENT_DYNAMIC_CLASS( className, baseClassName )
/**
Used in a C++ implementation file to complete the declaration of a class
@header{wx/object.h}
*/
-#define IMPLEMENT_DYNAMIC_CLASS2( className, baseClassName1, baseClassName2 )
+#define wxIMPLEMENT_DYNAMIC_CLASS2( className, baseClassName1, baseClassName2 )
+
+/**
+ Used in a C++ implementation file to complete the declaration of a class
+ that has run-time type information, and whose instances can be created
+ dynamically. The same as wxIMPLEMENT_DYNAMIC_CLASS().
+
+ @header{wx/object.h}
+*/
+#define wxIMPLEMENT_CLASS( className, baseClassName )
+
+/**
+ Used in a C++ implementation file to complete the declaration of a class
+ that has run-time type information and two base classes, and whose instances
+ can be created dynamically. The same as wxIMPLEMENT_DYNAMIC_CLASS2().
+
+ @header{wx/object.h}
+*/
+#define wxIMPLEMENT_CLASS2( className, baseClassName1, baseClassName2 )
/**
Same as @c const_cast<T>(x) if the compiler supports const cast or @c (T)x for
class wxSampleMultiButtonEditor : public wxPGTextCtrlEditor
{
- DECLARE_DYNAMIC_CLASS(wxSampleMultiButtonEditor)
+ wxDECLARE_DYNAMIC_CLASS(wxSampleMultiButtonEditor);
+
public:
wxSampleMultiButtonEditor() {}
virtual ~wxSampleMultiButtonEditor() {}
wxEvent& event ) const;
};
- IMPLEMENT_DYNAMIC_CLASS(wxSampleMultiButtonEditor, wxPGTextCtrlEditor)
+ wxIMPLEMENT_DYNAMIC_CLASS(wxSampleMultiButtonEditor, wxPGTextCtrlEditor);
wxPGWindowList wxSampleMultiButtonEditor::CreateControls( wxPropertyGrid* propGrid,
wxPGProperty* property,
@endcode
Since wxPGProperty derives from wxObject, you can use standard
- DECLARE_DYNAMIC_CLASS and IMPLEMENT_DYNAMIC_CLASS macros. From the
+ wxDECLARE_DYNAMIC_CLASS and wxIMPLEMENT_DYNAMIC_CLASS macros. From the
above example they were omitted for sake of simplicity, and besides,
they are only really needed if you need to use wxRTTI with your
property class.
@see EndEditLabel(), wxTreeEvent
*/
virtual wxTextCtrl *EditLabel(const wxTreeItemId& item,
- wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
+ wxClassInfo* textCtrlClass = wxCLASSINFO(wxTextCtrl));
/**
Ends label editing. If @a cancelEdit is @true, the edit will be
zero or positive value if the first item is less than, equal to or
greater than the second one.
- Please note that you @b must use wxRTTI macros DECLARE_DYNAMIC_CLASS()
- and IMPLEMENT_DYNAMIC_CLASS() if you override this function because
+ Please note that you @b must use wxRTTI macros wxDECLARE_DYNAMIC_CLASS()
+ and wxIMPLEMENT_DYNAMIC_CLASS() if you override this function because
otherwise the base class considers that it is not overridden and uses
the default comparison, i.e. sorts the items alphabetically, which
allows it optimize away the calls to the virtual function completely.
projects / wxWidgets.git / commitdiff
