Catagorized all functions and macros belonging to the RTTI and Versioning groups.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@52479 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/interface/app.h b/interface/app.h
index a194cd23de077aca0bb4f9a192f9b9e01a3fcb05..a23aa4ea91493046432da4271ed5b7c147edce0f 100644 (file)
--- a/interface/app.h
+++ b/interface/app.h
@@ -608,38 +608,53 @@ public:
 // Global functions/macros
 // ============================================================================
 
 // Global functions/macros
 // ============================================================================
 

-/**
-    The global pointer to the singleton wxApp object.

 
 

-    @see wxApp::GetInstance()
-*/
-wxApp *wxTheApp;
+/** @ingroup group_funcmacro_rtti */
+//@{

 
 /**
 
 /**

-    This is used in headers to create a forward declaration of the
-    wxGetApp() function implemented by wxIMPLEMENT_APP().
+    This is used in headers to create a forward declaration of the wxGetApp()
+    function implemented by IMPLEMENT_APP().

 
     It creates the declaration @a className wxGetApp(void).
 
     It creates the declaration @a className wxGetApp(void).

+
+    @header{wx/app.h}
+

     Example:
 
     @code
     Example:
 
     @code

-    wxDECLARE_APP(MyApp)
+    DECLARE_APP(MyApp)

     @endcode
 */
     @endcode
 */

-#define wxDECLARE_APP(className)     /* implementation is private */
+#define DECLARE_APP( appClassName )

 
 /**
     This is used in the application class implementation file to make the
     application class known to wxWidgets for dynamic construction.
 
 /**
     This is used in the application class implementation file to make the
     application class known to wxWidgets for dynamic construction.

+
+    @header{wx/app.h}
+

     Example:
 
     @code
     IMPLEMENT_APP(MyApp)
     @endcode
 
     Example:
 
     @code
     IMPLEMENT_APP(MyApp)
     @endcode
 

-    See also DECLARE_APP().
+    @see DECLARE_APP().
+*/
+#define IMPLEMENT_APP( appClassName )
+
+//@}
+
+
+
+
+/**
+    The global pointer to the singleton wxApp object.
+
+    @see wxApp::GetInstance()

 */
 */

-#define IMPLEMENT_APP(className)     /* implementation is private */
+wxApp *wxTheApp;

 
 /**
     This function doesn't exist in wxWidgets but it is created by using
 
 /**
     This function doesn't exist in wxWidgets but it is created by using

diff --git a/interface/object.h b/interface/object.h
index 3024b4c8f2638f2250b923ebaf95eda2224baf30..bc9e0663db9800293b2dacfe6926073a6da01f94 100644 (file)
--- a/interface/object.h
+++ b/interface/object.h
@@ -384,64 +384,96 @@ public:
 // Global functions/macros
 // ============================================================================
 
 // 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
 
 /**
     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
     {
     Example:
 
     @code
     class wxCommand: public wxObject
     {

-      DECLARE_ABSTRACT_CLASS(wxCommand)
+        DECLARE_ABSTRACT_CLASS(wxCommand)

 
 

-     private:
-      ...
-     public:
-      ...
+    private:
+        ...
+    public:
+        ...

     };
     @endcode
 */
     };
     @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( name )

 
 /**
 
 /**

-    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
     Example:
 
     @code


@@ -449,109 +481,101 @@ classname* wxConstCast();
 
     wxCommand::wxCommand(void)
     {
 
     wxCommand::wxCommand(void)
     {

-    ...
+        ...

     }
     @endcode
 */
     }
     @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<T>(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<T>(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<T>(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<classname *>(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( object, className )

 
 /**
     This is defined in debug mode to be call the redefined new operator
 
 /**
     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.
     @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( object, 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<classname *>(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( object, 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& name);
+
+//@}

 
 

diff --git a/interface/platform.h b/interface/platform.h
index 651e779d55e7fa5545a3c882889dc123afc8f859..04f1831d79d45bc9b46a690b59bd6f81d3b91ff4 100644 (file)
--- a/interface/platform.h
+++ b/interface/platform.h
@@ -6,51 +6,33 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 

-/**
-Same as wxCHECK_VERSION() but also checks that
-@c wxSUBRELEASE_NUMBER is at least @e subrel.
-*/
-#define bool wxCHECK_VERSION_FULL(major, minor, release, subrel)     /* implementation is private */
-
+/** @ingroup group_funcmacro_version */
+//@{

 
 /**
 
 /**

-This is a macro which evaluates to @true if the current wxWidgets version is at
-least major.minor.release.
-For example, to test if the program is compiled with wxWidgets 2.2 or higher,
-the following can be done:
-
-@code
-wxString s;
-#if wxCHECK_VERSION(2, 2, 0)
-    if ( s.StartsWith("foo") )
-#else // replacement code for old version
-    if ( strncmp(s, "foo", 3) == 0 )
-#endif
-    {
-        ...
-    }
-@endcode
+    Returns @true if the compiler being used is GNU C++ and its version is
+    at least major.minor or greater. Returns @false otherwise.

 */
 */

-#define bool wxCHECK_VERSION(major, minor, release)     /* implementation is private */
+#define wxCHECK_GCC_VERSION( major, minor )

 
 /**
 
 /**

-    Returns 1 if the compiler being used to compile the code is Visual C++
-    compiler version @a major or greater. Otherwise, and also if
-    the compiler is not Visual C++ at all, returns 0.
+    Returns @true if the compiler being used is Sun CC Pro and its version is
+    at least major.minor or greater. Returns @false otherwise.

 */
 */

-#define bool wxCHECK_VISUALC_VERSION(major)     /* implementation is private */
+#define wxCHECK_SUNCC_VERSION( major, minor )

 
 /**
 
 /**

-    Returns 1 if the compiler being used to compile the code is GNU C++
-    compiler (g++) version major.minor or greater. Otherwise, and also if
-    the compiler is not GNU C++ at all, returns 0.
+    Returns @true if the compiler being used is Visual C++ and its version is
+    at least major or greater. Returns @false otherwise.

 */
 */

-#define bool wxCHECK_GCC_VERSION(major, minor)     /* implementation is private */
+#define wxCHECK_VISUALC_VERSION( major )

 
 /**
 
 /**

-    Returns 1 if the compiler being used to compile the code is Sun CC Pro
-    compiler and its version is at least @c major.minor. Otherwise returns
-    0.
+    Returns @true if the version of w32api headers used is major.minor or
+    greater. Otherwise, and also if we are not compiling with MinGW32/Cygwin
+    under Win32 at all, returns @false.

 */
 */

-#define bool wxCHECK_SUNCC_VERSION(major, minor)     /* implementation is private */
+#define wxCHECK_W32API_VERSION( major, minor )
+
+//@}

 
 

diff --git a/interface/version.h b/interface/version.h
new file mode 100644 (file)
index 0000000..2fedd80
--- /dev/null
+++ b/interface/version.h
@@ -0,0 +1,40 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        version.h
+// Purpose:     wxWidgets version numbers
+// Author:      wxWidgets team
+// RCS-ID:      $Id: numdlg.h 52425 2008-03-10 15:24:38Z FM $
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+/** @ingroup group_funcmacro_version */
+//@{
+
+/**
+    This is a macro which evaluates to @true if the current wxWidgets version
+    is at least major.minor.release.
+    
+    For example, to test if the program is compiled with wxWidgets 2.2 or
+    higher, the following can be done:
+    
+    @code
+        wxString s;
+    #if wxCHECK_VERSION(2, 2, 0)
+        if ( s.StartsWith("foo") )
+    #else // replacement code for old version
+        if ( strncmp(s, "foo", 3) == 0 )
+    #endif
+        {
+            ...
+        }
+    @endcode
+*/
+#define wxCHECK_VERSION( major, minor, release )
+
+/**
+    Same as wxCHECK_VERSION() but also checks that wxSUBRELEASE_NUMBER is at
+    least subrel.
+*/
+#define wxCHECK_VERSION_FULL( major, minor, release, subrel )
+
+//@}
+