X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e54c96f187f46c06bd36be8cd52b35c19884aa2b..d36dbec9c6b6559a597f10794617c21a344e5575:/interface/object.h diff --git a/interface/object.h b/interface/object.h index 3024b4c8f2..c56d9bba91 100644 --- a/interface/object.h +++ b/interface/object.h @@ -384,64 +384,96 @@ public: // Global functions/macros // ============================================================================ +/** @ingroup group_funcmacro_rtti */ +//@{ + /** - 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. + Returns a pointer to the wxClassInfo object associated with this class. + + @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() /* implementation is private */ +#define DECLARE_CLASS( 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. The same as DECLARE_CLASS(). + + @header{wx/object.h} + Example: @code class wxCommand: public wxObject { - DECLARE_ABSTRACT_CLASS(wxCommand) + DECLARE_ABSTRACT_CLASS(wxCommand) - private: - ... - public: - ... + private: + ... + public: + ... }; @endcode */ -#define DECLARE_ABSTRACT_CLASS() /* implementation is private */ +#define DECLARE_ABSTRACT_CLASS( className ) /** - Returns a pointer to the wxClassInfo object associated with this class. -*/ -#define wxClassInfo* CLASSINFO() /* implementation is private */ + 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(). -/** - Same as @c reinterpret_castT(x) if the compiler supports reinterpret cast or - @c (T)x for old compilers. + @header{wx/object.h} - @see wx_const_cast(), wx_static_cast() + Example: + + @code + class wxFrame: public wxWindow + { + DECLARE_DYNAMIC_CLASS(wxFrame) + + private: + const wxString& frameTitle; + public: + ... + }; + @endcode */ -T wx_reinterpret_cast(); +#define DECLARE_DYNAMIC_CLASS( className ) /** - 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 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_CLASS2() /* implementation is private */ +#define IMPLEMENT_CLASS( className, baseClassName ) /** - This macro expands into @c const_castclassname *(ptr) if the compiler - supports @e const_cast or into an old, C-style cast, otherwise. + 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(). - @see wx_const_cast(), wxDynamicCast(), wxStaticCast() + @header{wx/object.h} */ -classname* wxConstCast(); +#define IMPLEMENT_CLASS2( className, baseClassName1, baseClassName2 ) /** - Used in a C++ implementation file to complete the declaration of - a class that has run-time type information. The same as IMPLEMENT_CLASS. + Used in a C++ implementation file to complete the declaration of a class + that has run-time type information. The same as IMPLEMENT_CLASS(). + + @header{wx/object.h} + Example: @code @@ -449,109 +481,101 @@ classname* wxConstCast(); wxCommand::wxCommand(void) { - ... + ... } @endcode */ -#define IMPLEMENT_ABSTRACT_CLASS() /* implementation is private */ +#define IMPLEMENT_ABSTRACT_CLASS( className, baseClassName ) /** - 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. + 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(). + + @header{wx/object.h} */ -#define IMPLEMENT_CLASS() /* implementation is private */ +#define IMPLEMENT_ABSTRACT_CLASS2( className, baseClassName1, baseClassName2 ) /** - This macro is equivalent to @c wxDynamicCast(this, classname) but the - latter provokes spurious compilation warnings from some compilers (because it - tests whether @c this pointer is non-@NULL which is always @true), so - this macro should be used to avoid them. + 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. - @see wxDynamicCast() + @header{wx/object.h} + + Example: + + @code + IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow) + + wxFrame::wxFrame(void) + { + ... + } + @endcode */ -classname* wxDynamicCastThis(); +#define IMPLEMENT_DYNAMIC_CLASS( className, baseClassName ) /** - 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. Use this for classes derived from two - base classes. + 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. Use this for classes derived from two base classes. + + @header{wx/object.h} */ -#define IMPLEMENT_DYNAMIC_CLASS2() /* implementation is private */ +#define IMPLEMENT_DYNAMIC_CLASS2( className, baseClassName1, baseClassName2 ) /** - Creates and returns an object of the given class, if the class has been - registered with the dynamic class system using DECLARE... and IMPLEMENT... - macros. + Same as const_cast(x) if the compiler supports const cast or (T)x for + old compilers. Unlike wxConstCast(), the cast it to the type T and not to + T * and also the order of arguments is the same as for the standard cast. + + @header{wx/defs.h} + + @see wx_reinterpret_cast(), wx_static_cast() */ -wxObject* wxCreateDynamicObject(const wxString& className); +#define wx_const_cast(T, x) /** - 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(). - Example: + Same as reinterpret_cast(x) if the compiler supports reinterpret cast or + (T)x for old compilers. - @code - class wxFrame: public wxWindow - { - DECLARE_DYNAMIC_CLASS(wxFrame) + @header{wx/defs.h} - private: - const wxString& frameTitle; - public: - ... - }; - @endcode + @see wx_const_cast(), wx_static_cast() */ -#define DECLARE_DYNAMIC_CLASS() /* implementation is private */ +#define wx_reinterpret_cast(T, x) /** - Same as @c const_castT(x) if the compiler supports const cast or - @c (T)x for old compilers. Unlike wxConstCast(), - the cast it to the type @e T and not to @c T * and also the order of - arguments is the same as for the standard cast. + Same as static_cast(x) if the compiler supports static cast or (T)x for + old compilers. Unlike wxStaticCast(), there are no checks being done and + the meaning of the macro arguments is exactly the same as for the standard + static cast, i.e. T is the full type name and star is not appended to it. - @see wx_reinterpret_cast(), wx_static_cast() + @header{wx/defs.h} + + @see wx_const_cast(), wx_reinterpret_cast(), wx_truncate_cast() */ -T wx_const_cast(); +#define wx_static_cast(T, x) /** - 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. + This case doesn’t correspond to any standard cast but exists solely to make + casts which possibly result in a truncation of an integer value more + readable. + + @header{wx/defs.h} */ -#define IMPLEMENT_ABSTRACT_CLASS2() /* implementation is private */ +#define wx_truncate_cast(T, x) /** - This macro returns the pointer @e ptr cast to the type @e classname * if - the pointer is of this type (the check is done during the run-time) or - @NULL otherwise. Usage of this macro is preferred over obsoleted - wxObject::IsKindOf() function. - The @e ptr argument may be @NULL, in which case @NULL will be - returned. - Example: + This macro expands into const_cast(ptr) if the compiler + supports const_cast or into an old, C-style cast, otherwise. - @code - wxWindow *win = wxWindow::FindFocus(); - wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl); - if ( text ) - { - // a text control has the focus... - } - else - { - // no window has the focus or it is not a text control - } - @endcode + @header{wx/defs.h} - @see @ref overview_runtimeclassoverview "RTTI overview", wxDynamicCastThis(), - wxConstCast(), wxStaticCast() + @see wx_const_cast(), wxDynamicCast(), wxStaticCast() */ -classname* wxDynamicCast(); +#define wxConstCast( ptr, classname ) /** This is defined in debug mode to be call the redefined new operator @@ -562,43 +586,72 @@ classname* wxDynamicCast(); @endcode In non-debug mode, this is defined as the normal new operator. + + @header{wx/object.h} */ -#define WXDEBUG_NEW() /* implementation is private */ +#define WXDEBUG_NEW( arg ) /** - This macro checks that the cast is valid in debug mode (an assert failure will - result if @c wxDynamicCast(ptr, classname) == @NULL) and then returns the - result of executing an equivalent of @c static_castclassname *(ptr). + This macro returns the pointer @e ptr cast to the type @e classname * if + the pointer is of this type (the check is done during the run-time) or + @NULL otherwise. Usage of this macro is preferred over obsoleted + wxObject::IsKindOf() function. - @see wx_static_cast(), wxDynamicCast(), wxConstCast() + The @e ptr argument may be @NULL, in which case @NULL will be returned. + + @header{wx/object.h} + + Example: + + @code + wxWindow *win = wxWindow::FindFocus(); + wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl); + if ( text ) + { + // a text control has the focus... + } + else + { + // no window has the focus or it is not a text control + } + @endcode + + @see @ref overview_runtimeclassoverview "RTTI Overview", + wxDynamicCastThis(), wxConstCast(), wxStaticCast() */ -classname* wxStaticCast(); +#define wxDynamicCast( ptr, classname ) /** - Same as @c static_castT(x) if the compiler supports static cast or - @c (T)x for old compilers. Unlike wxStaticCast(), - there are no checks being done and the meaning of the macro arguments is exactly - the same as for the standard static cast, i.e. @e T is the full type name and - star is not appended to it. + This macro is equivalent to wxDynamicCast() but the latter provokes + spurious compilation warnings from some compilers (because it tests whether + @c this pointer is non-@NULL which is always true), so this macro should be + used to avoid them. - @see wx_const_cast(), wx_reinterpret_cast(), wx_truncate_cast() + @header{wx/object.h} + + @see wxDynamicCast() */ -T wx_static_cast(); +#define wxDynamicCastThis( classname ) /** - 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. - Example: + This macro checks that the cast is valid in debug mode (an assert failure + will result if wxDynamicCast(ptr, classname) == @NULL) and then returns the + result of executing an equivalent of static_cast(ptr). - @code - IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow) + @header{wx/object.h} - wxFrame::wxFrame(void) - { - ... - } - @endcode + @see wx_static_cast(), wxDynamicCast(), wxConstCast() */ -#define IMPLEMENT_DYNAMIC_CLASS() /* implementation is private */ +#define wxStaticCast( ptr, classname ) + +/** + Creates and returns an object of the given class, if the class has been + registered with the dynamic class system using DECLARE... and IMPLEMENT... + macros. + + @header{wx/object.h} +*/ +wxObject *wxCreateDynamicObject(const wxString& className); + +//@}