Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@52479 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Bryan Petty
2008-03-14 07:44:48 +00:00
parent 4b8e857f88
commit 8af7f7c125
4 changed files with 266 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
interface/app.h
View File

@@ -608,38 +608,53 @@ public:
// Global functions/macros // Global functions/macros
// ============================================================================ // ============================================================================
/**
The global pointer to the singleton wxApp object.
@see wxApp::GetInstance() /** @ingroup group_funcmacro_rtti */
*/ //@{
wxApp *wxTheApp;
/** /**
This is used in headers to create a forward declaration of the This is used in headers to create a forward declaration of the wxGetApp()
wxGetApp() function implemented by wxIMPLEMENT_APP(). 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: Example:
@code @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 This is used in the application class implementation file to make the
application class known to wxWidgets for dynamic construction. application class known to wxWidgets for dynamic construction.
@header{wx/app.h}
Example: Example:
@code @code
IMPLEMENT_APP(MyApp) IMPLEMENT_APP(MyApp)
@endcode @endcode
See also DECLARE_APP(). @see DECLARE_APP().
*/ */
#define IMPLEMENT_APP(className) /* implementation is private */ #define IMPLEMENT_APP( appClassName )
//@}
/**
The global pointer to the singleton wxApp object.
@see wxApp::GetInstance()
*/
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

313
interface/object.h
View File

@@ -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 Returns a pointer to the wxClassInfo object associated with this class.
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 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 )
/** /**
Used inside a class declaration to declare that the class should be 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 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: Example:
@code @code
class wxCommand: public wxObject class wxCommand: public wxObject
{ {
DECLARE_ABSTRACT_CLASS(wxCommand) DECLARE_ABSTRACT_CLASS(wxCommand)
private: private:
... ...
public: 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. 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().
@header{wx/object.h}
Example:
@code
class wxFrame: public wxWindow
{
DECLARE_DYNAMIC_CLASS(wxFrame)
private:
const wxString& frameTitle;
public:
...
};
@endcode
*/ */
#define wxClassInfo* CLASSINFO() /* implementation is private */ #define DECLARE_DYNAMIC_CLASS( name )
/** /**
Same as @c reinterpret_castT(x) if the compiler supports reinterpret cast or Used in a C++ implementation file to complete the declaration of a class
@c (T)x for old compilers. that has run-time type information. The same as IMPLEMENT_ABSTRACT_CLASS().
@see wx_const_cast(), wx_static_cast() @header{wx/object.h}
*/ */
T wx_reinterpret_cast(); #define IMPLEMENT_CLASS( className, baseClassName )
/** /**
Used in a C++ implementation file to complete the declaration of a Used in a C++ implementation file to complete the declaration of a class
class that has run-time type information and two base classes. The that has run-time type information and two base classes. The same as
same as IMPLEMENT_ABSTRACT_CLASS2. IMPLEMENT_ABSTRACT_CLASS2().
@header{wx/object.h}
*/ */
#define IMPLEMENT_CLASS2() /* implementation is private */ #define IMPLEMENT_CLASS2( className, baseClassName1, baseClassName2 )
/** /**
This macro expands into @c const_castclassname *(ptr) if the compiler Used in a C++ implementation file to complete the declaration of a class
supports @e const_cast or into an old, C-style cast, otherwise. that has run-time type information. The same as IMPLEMENT_CLASS().
@see wx_const_cast(), wxDynamicCast(), wxStaticCast() @header{wx/object.h}
*/
classname* wxConstCast();
/**
Used in a C++ implementation file to complete the declaration of
a class that has run-time type information. The same as IMPLEMENT_CLASS.
Example: Example:
@code @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 Used in a C++ implementation file to complete the declaration of a class
a class that has run-time type information. The same as that has run-time type information and two base classes. The same as
IMPLEMENT_ABSTRACT_CLASS. 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 Used in a C++ implementation file to complete the declaration of a class
latter provokes spurious compilation warnings from some compilers (because it that has run-time type information, and whose instances can be created
tests whether @c this pointer is non-@NULL which is always @true), so dynamically.
this macro should be used to avoid them.
@see wxDynamicCast() @header{wx/object.h}
*/
classname* wxDynamicCastThis();
/**
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.
*/
#define IMPLEMENT_DYNAMIC_CLASS2() /* implementation is private */
/**
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.
*/
wxObject* wxCreateDynamicObject(const wxString& 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().
Example: Example:
@code @code
class wxFrame: public wxWindow IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
{
DECLARE_DYNAMIC_CLASS(wxFrame)
private: wxFrame::wxFrame(void)
const wxString& frameTitle; {
public: ...
... }
};
@endcode @endcode
*/ */
#define DECLARE_DYNAMIC_CLASS() /* implementation is private */ #define IMPLEMENT_DYNAMIC_CLASS( className, baseClassName )
/** /**
Same as @c const_castT(x) if the compiler supports const cast or Used in a C++ implementation file to complete the declaration of a class
@c (T)x for old compilers. Unlike wxConstCast(), that has run-time type information, and whose instances can be created
the cast it to the type @e T and not to @c T * and also the order of dynamically. Use this for classes derived from two base classes.
arguments is the same as for the standard cast.
@header{wx/object.h}
*/
#define IMPLEMENT_DYNAMIC_CLASS2( className, baseClassName1, baseClassName2 )
/**
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() @see wx_reinterpret_cast(), wx_static_cast()
*/ */
T wx_const_cast(); #define wx_const_cast(T, x)
/** /**
Used in a C++ implementation file to complete the declaration of Same as reinterpret_cast<T>(x) if the compiler supports reinterpret cast or
a class that has run-time type information and two base classes. The same as (T)x for old compilers.
IMPLEMENT_CLASS2.
@header{wx/defs.h}
@see wx_const_cast(), wx_static_cast()
*/ */
#define IMPLEMENT_ABSTRACT_CLASS2() /* implementation is private */ #define wx_reinterpret_cast(T, x)
/** /**
This macro returns the pointer @e ptr cast to the type @e classname * if Same as static_cast<T>(x) if the compiler supports static cast or (T)x for
the pointer is of this type (the check is done during the run-time) or old compilers. Unlike wxStaticCast(), there are no checks being done and
@NULL otherwise. Usage of this macro is preferred over obsoleted the meaning of the macro arguments is exactly the same as for the standard
wxObject::IsKindOf() function. static cast, i.e. T is the full type name and star is not appended to it.
The @e ptr argument may be @NULL, in which case @NULL will be
returned.
Example:
@code @header{wx/defs.h}
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(), @see wx_const_cast(), wx_reinterpret_cast(), wx_truncate_cast()
wxConstCast(), wxStaticCast()
*/ */
classname* wxDynamicCast(); #define wx_static_cast(T, x)
/**
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 wx_truncate_cast(T, x)
/**
This macro expands into const_cast<classname *>(ptr) if the compiler
supports const_cast or into an old, C-style cast, otherwise.
@header{wx/defs.h}
@see wx_const_cast(), wxDynamicCast(), wxStaticCast()
*/
#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 @endcode
In non-debug mode, this is defined as the normal new operator. 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 This macro returns the pointer @e ptr cast to the type @e classname * if
result if @c wxDynamicCast(ptr, classname) == @NULL) and then returns the the pointer is of this type (the check is done during the run-time) or
result of executing an equivalent of @c static_castclassname *(ptr). @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.
*/
classname* wxStaticCast();
/** @header{wx/object.h}
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.
@see wx_const_cast(), wx_reinterpret_cast(), wx_truncate_cast()
*/
T wx_static_cast();
/**
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: Example:
@code @code
IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow) wxWindow *win = wxWindow::FindFocus();
wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
wxFrame::wxFrame(void) if ( text )
{ {
... // a text control has the focus...
}
else
{
// no window has the focus or it is not a text control
} }
@endcode @endcode
*/
#define IMPLEMENT_DYNAMIC_CLASS() /* implementation is private */ @see @ref overview_runtimeclassoverview "RTTI Overview",
wxDynamicCastThis(), wxConstCast(), wxStaticCast()
*/
#define wxDynamicCast( object, className )
/**
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.
@header{wx/object.h}
@see wxDynamicCast()
*/
#define wxDynamicCastThis( className )
/**
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).
@header{wx/object.h}
@see wx_static_cast(), wxDynamicCast(), wxConstCast()
*/
#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);
//@}

52
interface/platform.h
View File

@@ -6,51 +6,33 @@
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /** @ingroup group_funcmacro_version */
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 */
/** /**
This is a macro which evaluates to @true if the current wxWidgets version is at Returns @true if the compiler being used is GNU C++ and its version is
least major.minor.release. at least major.minor or greater. Returns @false otherwise.
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 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++ Returns @true if the compiler being used is Sun CC Pro and its version is
compiler version @a major or greater. Otherwise, and also if at least major.minor or greater. Returns @false otherwise.
the compiler is not Visual C++ at all, returns 0.
*/ */
#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++ Returns @true if the compiler being used is Visual C++ and its version is
compiler (g++) version major.minor or greater. Otherwise, and also if at least major or greater. Returns @false otherwise.
the compiler is not GNU C++ at all, returns 0.
*/ */
#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 Returns @true if the version of w32api headers used is major.minor or
compiler and its version is at least @c major.minor. Otherwise returns greater. Otherwise, and also if we are not compiling with MinGW32/Cygwin
0. under Win32 at all, returns @false.
*/ */
#define bool wxCHECK_SUNCC_VERSION(major, minor) /* implementation is private */ #define wxCHECK_W32API_VERSION( major, minor )
//@}

40
interface/version.h Normal file
View File

@@ -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 )
//@}