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

Finished review/fixes of Math and Miscellaneous categories of functions and macros.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@52743 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Bryan Petty
2008-03-23 18:24:32 +00:00
parent bddd07670f
commit 7fa7088e4c
17 changed files with 665 additions and 494 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
docs/doxygen/groups/funcmacro_math.h
View File

@@ -11,7 +11,5 @@
@defgroup group_funcmacro_math Math @defgroup group_funcmacro_math Math
@ingroup group_funcmacro @ingroup group_funcmacro
@header{wx/math.h}
*/ */

64
interface/base64.h
View File

@@ -17,9 +17,9 @@
/** /**
This function encodes the given data using base64. This function encodes the given data using base64.
To allocate the buffer of the correct size, use wxBase64EncodedSize() or call To allocate the buffer of the correct size, use wxBase64EncodedSize() or
this function with @a dst set to @NULL -- it will then return the necessary call this function with @a dst set to @NULL -- it will then return the
buffer size. necessary buffer size.
This raw encoding function overload writes the output string into the This raw encoding function overload writes the output string into the
provided buffer; the other overloads return it as a wxString. provided buffer; the other overloads return it as a wxString.
@@ -34,33 +34,39 @@
The length of the input data. The length of the input data.
@returns @c wxCONV_FAILED if the output buffer is too small. @returns @c wxCONV_FAILED if the output buffer is too small.
@header{wx/base64.h}
*/ */
size_t wxBase64Encode(char* dst, size_t dstLen, size_t wxBase64Encode(char* dst, size_t dstLen,
const void* src, const void* src,
size_t srcLen); size_t srcLen);
/** /**
This function encodes the given data using base64 and returns the output This function encodes the given data using base64 and returns the output as
as a wxString. a wxString.
There is no error return. There is no error return.
To allocate the buffer of the correct size, use wxBase64EncodedSize() or call To allocate the buffer of the correct size, use wxBase64EncodedSize() or
this function with @a dst set to @NULL -- it will then return the necessary call this function with @a dst set to @NULL -- it will then return the
buffer size. necessary buffer size.
@param src @param src
The input buffer, must not be @NULL. The input buffer, must not be @NULL.
@param srcLen @param srcLen
The length of the input data. The length of the input data.
@header{wx/base64.h}
*/ */
wxString wxBase64Encode(const void* src, size_t srcLen); wxString wxBase64Encode(const void* src, size_t srcLen);
/** /**
This function encodes the given data using base64 and returns the output This function encodes the given data using base64 and returns the output as
as a wxString. a wxString.
There is no error return. There is no error return.
@header{wx/base64.h}
*/ */
wxString wxBase64Encode(const wxMemoryBuffer& buf); wxString wxBase64Encode(const wxMemoryBuffer& buf);
@@ -69,6 +75,8 @@ wxString wxBase64Encode(const wxMemoryBuffer& buf);
Returns the size of the buffer necessary to contain the data encoded in a Returns the size of the buffer necessary to contain the data encoded in a
base64 string of length @e srcLen. This can be useful for allocating a base64 string of length @e srcLen. This can be useful for allocating a
buffer to be passed to wxBase64Decode(). buffer to be passed to wxBase64Decode().
@header{wx/base64.h}
*/ */
size_t wxBase64DecodedSize(size_t srcLen); size_t wxBase64DecodedSize(size_t srcLen);
@@ -76,32 +84,36 @@ size_t wxBase64DecodedSize(size_t srcLen);
Returns the length of the string with base64 representation of a buffer of Returns the length of the string with base64 representation of a buffer of
specified size @e len. This can be useful for allocating the buffer passed specified size @e len. This can be useful for allocating the buffer passed
to wxBase64Encode(). to wxBase64Encode().
@header{wx/base64.h}
*/ */
size_t wxBase64EncodedSize(size_t len); size_t wxBase64EncodedSize(size_t len);
/** /**
This function decodes a Base64-encoded string. This function decodes a Base64-encoded string.
This overload is a raw decoding function and decodes the data into the provided This overload is a raw decoding function and decodes the data into the
buffer @a dst of the given size @e dstLen. An error is returned if the buffer provided buffer @a dst of the given size @e dstLen. An error is returned if
is not large enough -- that is not at least wxBase64DecodedSize(srcLen)() bytes. the buffer is not large enough -- that is not at least
wxBase64DecodedSize(srcLen) bytes.
This overload returns the number of bytes written to the buffer or the This overload returns the number of bytes written to the buffer or the
necessary buffer size if @a dst was @NULL or @c wxCONV_FAILED on necessary buffer size if @a dst was @NULL or @c wxCONV_FAILED on error,
error, e.g. if the output buffer is too small or invalid characters were e.g. if the output buffer is too small or invalid characters were
encountered in the input string. encountered in the input string.
@param dst @param dst
Pointer to output buffer, may be @NULL to just compute the Pointer to output buffer, may be @NULL to just compute the necessary
necessary buffer size. buffer size.
@param dstLen @param dstLen
The size of the output buffer, ignored if dst is @NULL. The size of the output buffer, ignored if dst is @NULL.
@param src @param src
The input string, must not be @NULL. For the version using The input string, must not be @NULL. For the version using wxString,
wxString, the input string should contain only ASCII characters. the input string should contain only ASCII characters.
@param srcLen @param srcLen
The length of the input string or special value wxNO_LEN if the string is The length of the input string or special value wxNO_LEN if the string
NUL-terminated and the length should be computed by this function itself. is @NULL-terminated and the length should be computed by this function
itself.
@param mode @param mode
This parameter specifies the function behaviour when invalid characters This parameter specifies the function behaviour when invalid characters
are encountered in input. By default, any such character stops the are encountered in input. By default, any such character stops the
@@ -109,8 +121,10 @@ size_t wxBase64EncodedSize(size_t len);
white space characters are silently skipped instead. And if it is white space characters are silently skipped instead. And if it is
wxBase64DecodeMode_Relaxed, then all invalid characters are skipped. wxBase64DecodeMode_Relaxed, then all invalid characters are skipped.
@param posErr @param posErr
If this pointer is non-@NULL and an error occurs during If this pointer is non-@NULL and an error occurs during decoding, it is
decoding, it is filled with the index of the invalid character. filled with the index of the invalid character.
@header{wx/base64.h}
*/ */
size_t wxBase64Decode(void* dst, size_t dstLen, size_t wxBase64Decode(void* dst, size_t dstLen,
const char* src, const char* src,
@@ -127,6 +141,8 @@ size_t wxBase64Decode(void* dst, size_t dstLen,
This overload returns a buffer with the base64 decoded binary equivalent This overload returns a buffer with the base64 decoded binary equivalent
of the input string. In neither case is the buffer @NULL-terminated. of the input string. In neither case is the buffer @NULL-terminated.
@header{wx/base64.h}
*/ */
wxMemoryBuffer wxBase64Decode(const char* src, wxMemoryBuffer wxBase64Decode(const char* src,
size_t srcLen = wxNO_LEN, size_t srcLen = wxNO_LEN,
@@ -139,6 +155,8 @@ wxMemoryBuffer wxBase64Decode(const char* src,
This overload takes as input a wxString and returns the internally-allocated This overload takes as input a wxString and returns the internally-allocated
memory as a wxMemoryBuffer, containing the base64 decoded data. memory as a wxMemoryBuffer, containing the base64 decoded data.
@header{wx/base64.h}
*/ */
wxMemoryBuffer wxBase64Decode(const wxString& src, wxMemoryBuffer wxBase64Decode(const wxString& src,
wxBase64DecodeMode mode = wxBase64DecodeMode_Strict, wxBase64DecodeMode mode = wxBase64DecodeMode_Strict,

124
interface/colour.h
View File

@@ -10,11 +10,10 @@
@class wxColour @class wxColour
@wxheader{colour.h} @wxheader{colour.h}
A colour is an object representing a combination of Red, Green, and Blue (RGB) A colour is an object representing a combination of Red, Green, and Blue
intensity values, (RGB) intensity values, and is used to determine drawing colours. See the
and is used to determine drawing colours. See the entry for wxColourDatabase for how a pointer to a predefined, named colour
entry for wxColourDatabase for how a pointer to a predefined, may be returned instead of creating a new colour.
named colour may be returned instead of creating a new colour.
Valid RGB values are in the range 0 to 255. Valid RGB values are in the range 0 to 255.
@@ -24,18 +23,21 @@
@category{gdi} @category{gdi}
@stdobjects @stdobjects
::Objects:, ::wxNullColour, ::Pointers:, ::wxBLACK, ::wxWHITE, ::wxRED, ::wxNullColour, ::wxBLACK, ::wxWHITE, ::wxRED, ::wxBLUE, ::wxGREEN,
::wxBLUE, ::wxGREEN, ::wxCYAN, ::wxLIGHT_GREY, ::wxCYAN, ::wxLIGHT_GREY
@see wxColourDatabase, wxPen, wxBrush, wxColourDialog, wxSystemSettings @see wxColourDatabase, wxPen, wxBrush, wxColourDialog, wxSystemSettings
*/ */
class wxColour : public wxObject class wxColour : public wxObject
{ {
public: public:
//@{
/**
Copy constructor.
/**
Default constructor.
*/
wxColour();
/**
@param red @param red
The red value. The red value.
@param green @param green
@@ -43,22 +45,22 @@ public:
@param blue @param blue
The blue value. The blue value.
@param alpha @param alpha
The alpha value. Alpha values range from 0 (wxALPHA_TRANSPARENT) to 255 The alpha value. Alpha values range from 0 (wxALPHA_TRANSPARENT) to
(wxALPHA_OPAQUE). 255 (wxALPHA_OPAQUE).
*/
wxColour(unsigned char red, unsigned char green, unsigned char blue,
unsigned char alpha = wxALPHA_OPAQUE);
/**
@param colourName @param colourName
The colour name. The colour name.
@param colour
The colour to copy.
@see wxColourDatabase
*/ */
wxColour(); wxColour(const wxString& colourName);
wxColour(unsigned char red, unsigned char green,
unsigned char blue, /**
unsigned char alpha = wxALPHA_OPAQUE); Copy constructor.
wxColour(const wxString& colourNname); */
wxColour(const wxColour& colour); wxColour(const wxColour& colour);
//@}
/** /**
Returns the alpha value, on platforms where alpha is not yet supported, this Returns the alpha value, on platforms where alpha is not yet supported, this
@@ -71,24 +73,24 @@ public:
*/ */
unsigned char Blue() const; unsigned char Blue() const;
//@{
/** /**
is not Converts this colour to a wxString using the given flags.
The supported flags are wxC2S_NAME, to obtain the colour name (e.g.
wxColour(255,0,0) == "red"), wxC2S_CSS_SYNTAX, to obtain the colour in
the "rgb(r,g,b)" or "rgba(r,g,b,a)" syntax (e.g.
wxColour(255,0,0,85) == "rgba(255,0,0,0.333)"), and wxC2S_HTML_SYNTAX,
to obtain the colour as "#" followed by 6 hexadecimal digits (e.g.
wxColour(255,0,0) == "#FF0000").
This function never fails and always returns a non-empty string but
asserts if the colour has alpha channel (i.e. is non opaque) but
wxC2S_CSS_SYNTAX (which is the only one supporting alpha) is not
specified in flags. specified in flags.
@wxsince{2.7.0} @wxsince{2.7.0}
*/ */
wxString GetAsString(long flags); wxString GetAsString(long flags);
const wxC2S_NAME, to obtain the colour name (e.g.
wxColour(255,0,0) - "red"), wxC2S_CSS_SYNTAX, to obtain
the colour in the "rgb(r,g,b)" or "rgba(r,g,b,a)" syntax
(e.g. wxColour(255,0,0,85) - "rgba(255,0,0,0.333)"), and
wxC2S_HTML_SYNTAX, to obtain the colour as "#" followed
by 6 hexadecimal digits (e.g. wxColour(255,0,0) - "#FF0000").
This function never fails and always returns a non-empty string but asserts if
the colour has alpha channel (i.e. is non opaque) but
wxC2S_CSS_SYNTAX();
//@}
/** /**
Returns a pixel value which is platform-dependent. On Windows, a COLORREF is Returns a pixel value which is platform-dependent. On Windows, a COLORREF is
@@ -117,12 +119,15 @@ public:
//@{ //@{
/** /**
Sets the RGB intensity values using the given values (first overload), Sets the RGB intensity values using the given values (first overload),
extracting them from the packed long (second overload), using the given string (third overloard). extracting them from the packed long (second overload), using the given
string (third overloard).
When using third form, Set() accepts: colour names (those listed in When using third form, Set() accepts: colour names (those listed in
wxTheColourDatabase()), the CSS-like wxTheColourDatabase()), the CSS-like @c "rgb(r,g,b)" or
@c "rgb(r,g,b)" or @c "rgba(r,g,b,a)" syntax (case insensitive) @c "rgba(r,g,b,a)" syntax (case insensitive) and the HTML-like syntax
and the HTML-like syntax (i.e. @c "#" followed by 6 hexadecimal digits (i.e. @c "#" followed by 6 hexadecimal digits for red, green, blue
for red, green, blue components). components).
Returns @true if the conversion was successful, @false otherwise. Returns @true if the conversion was successful, @false otherwise.
@wxsince{2.7.0} @wxsince{2.7.0}
@@ -158,23 +163,11 @@ public:
}; };
/**
FIXME
*/
wxColour Objects:
;
/** /**
FIXME FIXME
*/ */
wxColour wxNullColour; wxColour wxNullColour;
/**
FIXME
*/
wxColour Pointers:
;
/** /**
FIXME FIXME
*/ */
@@ -211,3 +204,32 @@ wxColour wxCYAN;
wxColour wxLIGHT_GREY; wxColour wxLIGHT_GREY;
// ============================================================================
// Global functions/macros
// ============================================================================
/** @ingroup group_funcmacro_misc */
//@{
/**
Converts string to a wxColour best represented by the given string. Returns
@true on success.
@see wxToString(const wxColour&)
@header{wx/colour.h}
*/
bool wxFromString(const wxString& string, wxColour* colour);
/**
Converts the given wxColour into a string.
@see wxFromString(const wxString&, wxColour*)
@header{wx/colour.h}
*/
wxString wxToString(const wxColour& colour);
//@}

37
interface/cpp.h
View File

@@ -6,34 +6,47 @@
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** @ingroup group_funcmacro_misc */
//@{ //@{
/** /**
These macro return the concatenation of the tokens passed as their arguments. This macro returns the concatenation of the arguments passed. Unlike when
Unlike when using the preprocessor @c operator, the arguments undergo using the preprocessor operator, the arguments undergo macro expansion
the macro expansion before being concatenated. before being concatenated.
@header{wx/cpp.h}
*/ */
wxCONCAT(x1, x2); #define wxCONCAT(x1, x2)
wxCONCAT3(x1, x2, x3); #define wxCONCAT3(x1, x2, x3)
wxCONCAT4(x1, x2, x3, x4); #define wxCONCAT4(x1, x2, x3, x4)
wxCONCAT5(x1, x2, x3, x4, x5); #define wxCONCAT5(x1, x2, x3, x4, x5)
//@} //@}
/** @ingroup group_funcmacro_misc */
//@{
/** /**
Returns the string representation of the given symbol which can be either a Returns the string representation of the given symbol which can be either a
literal or a macro (hence the advantage of using this macro instead of the literal or a macro (hence the advantage of using this macro instead of the
standard preprocessor @c # operator which doesn't work with macros). standard preprocessor @c # operator which doesn't work with macros).
Notice that this macro always produces a @c char string, use Notice that this macro always produces a @c char string, use
wxSTRINGIZE_T() to build a wide string Unicode build. wxSTRINGIZE_T() to build a wide string Unicode build.
@see wxCONCAT() @see wxCONCAT()
@header{wx/cpp.h}
*/ */
#define wxSTRINGIZE(x) /* implementation is private */ #define wxSTRINGIZE(x)
/** /**
Returns the string representation of the given symbol as either an ASCII or Returns the string representation of the given symbol as either an ASCII or
Unicode string, depending on the current build. This is the Unicode-friendly Unicode string, depending on the current build. This is the
equivalent of wxSTRINGIZE(). Unicode-friendly equivalent of wxSTRINGIZE().
*/
#define wxSTRINGIZE_T(x) /* implementation is private */ @header{wx/cpp.h}
*/
#define wxSTRINGIZE_T(x)
//@}

26
interface/dde.h
View File

@@ -314,20 +314,30 @@ public:
// Global functions/macros // Global functions/macros
// ============================================================================ // ============================================================================
/** @ingroup group_funcmacro_misc */
//@{
/** /**
Called when wxWidgets exits, to clean up the DDE system. This no longer needs Called when wxWidgets exits, to clean up the DDE system. This no longer
to be needs to be called by the application.
called by the application.
See also wxDDEInitialize(). @see wxDDEInitialize()
@header{wx/dde.h}
*/ */
void wxDDECleanUp(); void wxDDECleanUp();
/** /**
Initializes the DDE system. May be called multiple times without harm. Initializes the DDE system. May be called multiple times without harm.
This no longer needs to be called by the application: it will be called
by wxWidgets if necessary. This no longer needs to be called by the application: it will be called by
See also wxDDEServer, wxDDEClient, wxDDEConnection, wxWidgets if necessary.
wxDDECleanUp().
@see wxDDEServer, wxDDEClient, wxDDEConnection, wxDDECleanUp()
@header{wx/dde.h}
*/ */
void wxDDEInitialize(); void wxDDEInitialize();
//@}

16
interface/debug.h
View File

@@ -202,3 +202,19 @@ void wxTrap();
//@} //@}
/** @ingroup group_funcmacro_misc */
//@{
/**
This macro expands to the name of the current function if the compiler
supports any of @c __FUNCTION__, @c __func__ or equivalent variables or
macros or to @NULL if none of them is available.
@header{wx/debug.h}
*/
#define __WXFUNCTION__
//@}

113
interface/defs.h
View File

@@ -67,11 +67,50 @@
/** @ingroup group_funcmacro_misc */
//@{
/** /**
This macro is similar to wxDEPRECATED() but can be used This macro can be used around a function declaration to generate warnings
to not only declare the function @a func as deprecated but to also provide indicating that this function is deprecated (i.e. obsolete and planned to
its (inline) implementation @e body. be removed in the future) when it is used. Only Visual C++ 7 and higher and
g++ compilers currently support this functionality.
Example of use:
@code
// old function, use wxString version instead
wxDEPRECATED( void wxGetSomething(char *buf, size_t len) );
// ...
wxString wxGetSomething();
@endcode
@header{wx/defs.h}
*/
#define wxDEPRECATED(function)
/**
This is a special version of wxDEPRECATED() macro which only does something
when the deprecated function is used from the code outside wxWidgets itself
but doesn't generate warnings when it is used from wxWidgets.
It is used with the virtual functions which are called by the library
itself -- even if such function is deprecated the library still has to call
it to ensure that the existing code overriding it continues to work, but
the use of this macro ensures that a deprecation warning will be generated
if this function is used from the user code or, in case of Visual C++, even
when it is simply overridden.
@header{wx/defs.h}
*/
#define wxDEPRECATED_BUT_USED_INTERNALLY(function)
/**
This macro is similar to wxDEPRECATED() but can be used to not only declare
the function @a function as deprecated but to also provide its (inline)
implementation @a body.
It can be used as following: It can be used as following:
@code @code
@@ -83,25 +122,32 @@
wxDEPRECATED_INLINE( void OldMethod(), NewMethod() ); wxDEPRECATED_INLINE( void OldMethod(), NewMethod() );
}; };
@endcode @endcode
@header{wx/defs.h}
*/ */
#define wxDEPRECATED_INLINE(func, body) /* implementation is private */ #define wxDEPRECATED_INLINE(func, body)
/** /**
@c wxEXPLICIT is a macro which expands to the C++ @c explicit keyword if @c wxEXPLICIT is a macro which expands to the C++ @c explicit keyword if
the compiler supports it or nothing otherwise. Thus, it can be used even in the the compiler supports it or nothing otherwise. Thus, it can be used even in
code which might have to be compiled with an old compiler without support for the code which might have to be compiled with an old compiler without
this language feature but still take advantage of it when it is available. support for this language feature but still take advantage of it when it is
*/ available.
@header{wx/defs.h}
*/
#define wxEXPLICIT
/** /**
GNU C++ compiler gives a warning for any class whose destructor is private GNU C++ compiler gives a warning for any class whose destructor is private
unless it has a friend. This warning may sometimes be useful but it doesn't unless it has a friend. This warning may sometimes be useful but it doesn't
make sense for reference counted class which always delete themselves (hence make sense for reference counted class which always delete themselves
destructor should be private) but don't necessarily have any friends, so this (hence destructor should be private) but don't necessarily have any
macro is provided to disable the warning in such case. The @a name parameter friends, so this macro is provided to disable the warning in such case. The
should be the name of the class but is only used to construct a unique friend @a name parameter should be the name of the class but is only used to
class name internally. Example of using the macro: construct a unique friend class name internally.
Example of using the macro:
@code @code
class RefCounted class RefCounted
@@ -119,46 +165,23 @@
@endcode @endcode
Notice that there should be no semicolon after this macro. Notice that there should be no semicolon after this macro.
@header{wx/defs.h}
*/ */
#define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name) /* implementation is private */ #define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name)
/**
This macro can be used around a function declaration to generate warnings
indicating that this function is deprecated (i.e. obsolete and planned to be
removed in the future) when it is used. Only Visual C++ 7 and higher and g++
compilers currently support this functionality.
Example of use:
@code
// old function, use wxString version instead
wxDEPRECATED( void wxGetSomething(char *buf, size_t len) );
// ...
wxString wxGetSomething();
@endcode
*/
/** /**
This macro is the same as the standard C99 @c va_copy for the compilers This macro is the same as the standard C99 @c va_copy for the compilers
which support it or its replacement for those that don't. It must be used to which support it or its replacement for those that don't. It must be used
preserve the value of a @c va_list object if you need to use it after to preserve the value of a @c va_list object if you need to use it after
passing it to another function because it can be modified by the latter. passing it to another function because it can be modified by the latter.
As with @c va_start, each call to @c wxVaCopy must have a matching As with @c va_start, each call to @c wxVaCopy must have a matching
@c va_end. @c va_end.
@header{wx/defs.h}
*/ */
void wxVaCopy(va_list argptrDst, va_list argptrSrc); void wxVaCopy(va_list argptrDst, va_list argptrSrc);
/** //@}
This is a special version of wxDEPRECATED() macro which
only does something when the deprecated function is used from the code outside
wxWidgets itself but doesn't generate warnings when it is used from wxWidgets.
It is used with the virtual functions which are called by the library itself --
even if such function is deprecated the library still has to call it to ensure
that the existing code overriding it continues to work, but the use of this
macro ensures that a deprecation warning will be generated if this function is
used from the user code or, in case of Visual C++, even when it is simply
overridden.
*/

33
interface/dynlib.h
View File

@@ -363,24 +363,31 @@ public:
// Global functions/macros // Global functions/macros
// ============================================================================ // ============================================================================
/** @ingroup group_funcmacro_misc */
//@{
/** /**
When loading a function from a DLL you always have to cast the returned When loading a function from a DLL you always have to cast the returned
@c void * pointer to the correct type and, even more annoyingly, you have to <tt>void *</tt> pointer to the correct type and, even more annoyingly, you
repeat this type twice if you want to declare and define a function pointer all have to repeat this type twice if you want to declare and define a function
in one line pointer all in one line.
This macro makes this slightly less painful by allowing you to specify the This macro makes this slightly less painful by allowing you to specify the
type only once, as the first parameter, and creating a variable of this type type only once, as the first parameter, and creating a variable of this
named after the function but with @c pfn prefix and initialized with the type named after the function but with @c pfn prefix and initialized with
function @a name from the wxDynamicLibrary the function @a name from the wxDynamicLibrary @a dynlib.
@e dynlib.
@param type @param type
the type of the function The type of the function.
@param name @param name
the name of the function to load, not a string (without quotes, The name of the function to load, not a string (without quotes, it is
it is quoted automatically by the macro) quoted automatically by the macro).
@param dynlib @param dynlib
the library to load the function from The library to load the function from.
*/
#define wxDYNLIB_FUNCTION(type, name, dynlib) /* implementation is private */ @header{wx/dynlib.h}
*/
#define wxDYNLIB_FUNCTION(type, name, dynlib)
//@}

19
interface/event.h
View File

@@ -2781,11 +2781,24 @@ public:
// ============================================================================
// Global functions/macros
// ============================================================================
/** @ingroup group_funcmacro_misc */
//@{
/** /**
In a GUI application, this function posts @a event to the specified @e dest In a GUI application, this function posts @a event to the specified @e dest
object using wxEvtHandler::AddPendingEvent. object using wxEvtHandler::AddPendingEvent().
Otherwise, it dispatches @a event immediately using wxEvtHandler::ProcessEvent. Otherwise, it dispatches @a event immediately using
See the respective documentation for details (and caveats). wxEvtHandler::ProcessEvent(). See the respective documentation for details
(and caveats).
@header{wx/event.h}
*/ */
void wxPostEvent(wxEvtHandler* dest, wxEvent& event); void wxPostEvent(wxEvtHandler* dest, wxEvent& event);
//@}

41
interface/font.h
View File

@@ -651,23 +651,11 @@ public:
}; };
/**
FIXME
*/
wxFont Objects:
;
/** /**
FIXME FIXME
*/ */
wxFont wxNullFont; wxFont wxNullFont;
/**
FIXME
*/
wxFont Pointers:
;
/** /**
FIXME FIXME
*/ */
@@ -689,3 +677,32 @@ wxFont wxITALIC_FONT;
wxFont wxSWISS_FONT; wxFont wxSWISS_FONT;
// ============================================================================
// Global functions/macros
// ============================================================================
/** @ingroup group_funcmacro_misc */
//@{
/**
Converts string to a wxFont best represented by the given string. Returns
@true on success.
@see wxToString(const wxFont&)
@header{wx/font.h}
*/
bool wxFromString(const wxString& string, wxFont* font);
/**
Converts the given wxFont into a string.
@see wxFromString(const wxString&, wxFont*)
@header{wx/font.h}
*/
wxString wxToString(const wxFont& font);
//@}

45
interface/longlong.h
View File

@@ -145,6 +145,9 @@ public:
// Global functions/macros // Global functions/macros
// ============================================================================ // ============================================================================
/** @ingroup group_funcmacro_misc */
//@{
/** /**
This macro is defined to contain the @c printf() format specifier using This macro is defined to contain the @c printf() format specifier using
which 64 bit integer numbers (i.e. those of type @c wxLongLong_t) can be which 64 bit integer numbers (i.e. those of type @c wxLongLong_t) can be
@@ -158,26 +161,14 @@ public:
@endcode @endcode
@see wxLL() @see wxLL()
*/
@header{wx/longlong.h}
*/
#define wxLongLongFmtSpec
/** /**
This macro is defined for the platforms with a native 64 bit integer type and This macro is defined for the platforms with a native 64 bit integer type
allows to define unsigned 64 bit compile time constants: and allow the use of 64 bit compile time constants:
@code
#ifdef wxLongLong_t
unsigned wxLongLong_t ll = wxULL(0x1234567890abcdef);
#endif
@endcode
@see wxLL(), wxLongLong
*/
wxLongLong_t wxULL(number);
/**
This macro is defined for the platforms with a native 64 bit integer type and
allows to define 64 bit compile time constants:
@code @code
#ifdef wxLongLong_t #ifdef wxLongLong_t
@@ -186,6 +177,26 @@ wxLongLong_t wxULL(number);
@endcode @endcode
@see wxULL(), wxLongLong @see wxULL(), wxLongLong
@header{wx/longlong.h}
*/ */
wxLongLong_t wxLL(number); wxLongLong_t wxLL(number);
/**
This macro is defined for the platforms with a native 64 bit integer type
and allow the use of 64 bit compile time constants:
@code
#ifdef wxLongLong_t
unsigned wxLongLong_t ll = wxULL(0x1234567890abcdef);
#endif
@endcode
@see wxLL(), wxLongLong
@header{wx/longlong.h}
*/
wxLongLong_t wxULL(number);
//@}

17
interface/math.h
View File

@@ -6,10 +6,23 @@
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** @ingroup group_funcmacro_math */
//@{
/** /**
Returns a non-zero value if @a x is neither infinite nor NaN (not a number), Returns a non-zero value if @a x is neither infinite nor NaN (not a
returns 0 otherwise. number), returns 0 otherwise.
@header{wx/math.h}
*/ */
int wxFinite(double x); int wxFinite(double x);
/**
Returns a non-zero value if x is NaN (not a number), returns 0 otherwise.
@header{wx/math.h}
*/
bool wxIsNaN(double x);
//@}

46
interface/scopeguard.h
View File

@@ -6,23 +6,13 @@
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** @ingroup group_funcmacro_misc */
//@{ //@{
/** /**
This family of macros is similar to wxON_BLOCK_EXIT() This macro ensures that the global @a function with 0, 1, 2 or more
but calls a method of the given object instead of a free function. parameters (up to some implementaton-defined limit) is executed on scope
*/ exit, whether due to a normal function return or because an exception has
wxON_BLOCK_EXIT_OBJ0(obj, method); been thrown. A typical example of its usage:
wxON_BLOCK_EXIT_OBJ1(obj, method, p1);
wxON_BLOCK_EXIT_OBJ2(obj, method, p1, p2);
//@}
//@{
/**
This family of macros allows to ensure that the global function @e func
with 0, 1, 2 or more parameters (up to some implementaton-defined limit) is
executed on scope exit, whether due to a normal function return or because an
exception has been thrown. A typical example of its usage:
@code @code
void *buf = malloc(size); void *buf = malloc(size);
@@ -30,13 +20,27 @@ wxON_BLOCK_EXIT_OBJ2(obj, method, p1, p2);
@endcode @endcode
Please see the original article by Andrei Alexandrescu and Petru Marginean Please see the original article by Andrei Alexandrescu and Petru Marginean
published in December 2000 issue of C/C++ Users Journal for more published in December 2000 issue of C/C++ Users Journal for more details.
details.
@see wxON_BLOCK_EXIT_OBJ() @see wxON_BLOCK_EXIT_OBJ0()
@header{wx/scopeguard.h}
*/ */
wxON_BLOCK_EXIT0(func); #define wxON_BLOCK_EXIT0(function)
wxON_BLOCK_EXIT1(func, p1); #define wxON_BLOCK_EXIT1(function, p1)
wxON_BLOCK_EXIT2(func, p1, p2); #define wxON_BLOCK_EXIT2(function, p1, p2)
//@}
/** @ingroup group_funcmacro_misc */
//@{
/**
This family of macros is similar to wxON_BLOCK_EXIT0(), but calls a method
of the given object instead of a free function.
@header{wx/scopeguard.h}
*/
#define wxON_BLOCK_EXIT_OBJ0(object, method)
#define wxON_BLOCK_EXIT_OBJ1(object, method, p1)
#define wxON_BLOCK_EXIT_OBJ2(object, method, p1, p2)
//@} //@}

19
interface/stockitem.h
View File

@@ -6,21 +6,26 @@
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** @ingroup group_funcmacro_misc */
//@{
/** /**
Returns label that should be used for given @a id element. Returns label that should be used for given @a id element.
@param id @param id
given id of the wxMenuItem, wxButton, wxToolBar tool, etc. Given id of the wxMenuItem, wxButton, wxToolBar tool, etc.
@param withCodes @param withCodes
if @false then strip accelerator code from the label; If @false then strip accelerator code from the label; useful for
useful for getting labels without accelerator char code like for toolbar getting labels without accelerator char code like for toolbar tooltip
tooltip or or on platforms without traditional keyboard like smartphones.
on platforms without traditional keyboard like smartphones
@param accelerator @param accelerator
optional accelerator string automatically added to label; useful Optional accelerator string automatically added to label; useful for
for building labels for wxMenuItem building labels for wxMenuItem.
@header{wx/stockitem.h}
*/ */
wxString wxGetStockLabel(wxWindowID id, bool withCodes = true, wxString wxGetStockLabel(wxWindowID id, bool withCodes = true,
const wxString& accelerator = wxEmptyString); const wxString& accelerator = wxEmptyString);
//@}

24
interface/string.h
View File

@@ -1248,27 +1248,3 @@ public:
wxChar* operator wxChar *(); wxChar* operator wxChar *();
}; };
// ============================================================================
// Global functions/macros
// ============================================================================
//@{
/**
Converts its argument to string.
See also: wxFromString().
*/
wxString wxToString(const wxColour& col);
wxString wxToString(const wxFont& col);
//@}
//@{
/**
Converts string to the type of the second argument. Returns @true on success.
See also: wxToString().
*/
bool wxFromString(const wxString& str, wxColour* col);
bool wxFromString(const wxString& str, wxFont* col);
//@}

412
interface/utils.h
View File

@@ -206,16 +206,229 @@ bool wxUnsetEnv(const wxString& var);
/** @ingroup group_funcmacro_misc */
//@{
/** /**
Returns the type of power source as one of @c wxPOWER_SOCKET, Returns battery state as one of @c wxBATTERY_NORMAL_STATE,
@c wxPOWER_BATTERY or @c wxPOWER_UNKNOWN. @c wxBATTERY_LOW_STATE, @c wxBATTERY_CRITICAL_STATE,
@c wxPOWER_UNKNOWN is also the default on platforms where this @c wxBATTERY_SHUTDOWN_STATE or @c wxBATTERY_UNKNOWN_STATE.
@c wxBATTERY_UNKNOWN_STATE is also the default on platforms where this
feature is not implemented (currently everywhere but MS Windows). feature is not implemented (currently everywhere but MS Windows).
@header{wx/utils.h} @header{wx/utils.h}
*/ */
wxBatteryState wxGetBatteryState();
/**
Returns the type of power source as one of @c wxPOWER_SOCKET,
@c wxPOWER_BATTERY or @c wxPOWER_UNKNOWN. @c wxPOWER_UNKNOWN is also the
default on platforms where this feature is not implemented (currently
everywhere but MS Windows).
@header{wx/utils.h}
*/
wxPowerType wxGetPowerType(); wxPowerType wxGetPowerType();
/**
Under X only, returns the current display name.
@see wxSetDisplayName()
@header{wx/utils.h}
*/
wxString wxGetDisplayName();
/**
For normal keys, returns @true if the specified key is currently down.
For togglable keys (Caps Lock, Num Lock and Scroll Lock), returns @true if
the key is toggled such that its LED indicator is lit. There is currently
no way to test whether togglable keys are up or down.
Even though there are virtual key codes defined for mouse buttons, they
cannot be used with this function currently.
@header{wx/utils.h}
*/
bool wxGetKeyState(wxKeyCode key);
/**
Returns the mouse position in screen coordinates.
@header{wx/utils.h}
*/
wxPoint wxGetMousePosition();
/**
Returns the current state of the mouse. Returns a wxMouseState instance
that contains the current position of the mouse pointer in screen
coordinates, as well as boolean values indicating the up/down status of the
mouse buttons and the modifier keys.
@header{wx/utils.h}
*/
wxMouseState wxGetMouseState();
/**
This function enables or disables all top level windows. It is used by
wxSafeYield().
@header{wx/utils.h}
*/
void wxEnableTopLevelWindows(bool enable = true);
/**
Find the deepest window at the given mouse position in screen coordinates,
returning the window if found, or @NULL if not.
@header{wx/utils.h}
*/
wxWindow* wxFindWindowAtPoint(const wxPoint& pt);
/**
@deprecated Replaced by wxWindow::FindWindowByLabel().
Find a window by its label. Depending on the type of window, the label may
be a window title or panel item label. If @a parent is @NULL, the search
will start from all top-level frames and dialog boxes; if non-@NULL, the
search will be limited to the given window hierarchy. The search is
recursive in both cases.
@header{wx/utils.h}
*/
wxWindow* wxFindWindowByLabel(const wxString& label,
wxWindow* parent = NULL);
/**
@deprecated Replaced by wxWindow::FindWindowByName().
Find a window by its name (as given in a window constructor or @e Create
function call). If @a parent is @NULL, the search will start from all
top-level frames and dialog boxes; if non-@NULL, the search will be limited
to the given window hierarchy. The search is recursive in both cases.
If no such named window is found, wxFindWindowByLabel() is called.
@header{wx/utils.h}
*/
wxWindow* wxFindWindowByName(const wxString& name, wxWindow* parent = NULL);
/**
Find a menu item identifier associated with the given frame's menu bar.
@header{wx/utils.h}
*/
int wxFindMenuItemId(wxFrame* frame, const wxString& menuString,
const wxString& itemString);
/**
@deprecated Ids generated by it can conflict with the Ids defined by the
user code, use @c wxID_ANY to assign ids which are guaranteed
to not conflict with the user-defined ids for the controls and
menu items you create instead of using this function.
Generates an integer identifier unique to this run of the program.
@header{wx/utils.h}
*/
long wxNewId();
/**
Ensures that Ids subsequently generated by wxNewId() do not clash with the
given @a id.
@header{wx/utils.h}
*/
void wxRegisterId(long id);
/**
Opens the @a url in user's default browser. If the @a flags parameter
contains @c wxBROWSER_NEW_WINDOW flag, a new window is opened for the URL
(currently this is only supported under Windows). The @a url may also be a
local file path (with or without the "file://" prefix), if it doesn't
correspond to an existing file and the URL has no scheme "http://" is
prepended to it by default.
Returns @true if the application was successfully launched.
@note For some configurations of the running user, the application which is
launched to open the given URL may be URL-dependent (e.g. a browser
may be used for local URLs while another one may be used for remote
URLs).
@header{wx/utils.h}
*/
bool wxLaunchDefaultBrowser(const wxString& url, int flags = 0);
/**
Loads a user-defined Windows resource as a string. If the resource is
found, the function creates a new character array and copies the data into
it. A pointer to this data is returned. If unsuccessful, @NULL is returned.
The resource must be defined in the @c .rc file using the following syntax:
@code
myResource TEXT file.ext
@endcode
Where @c file.ext is a file that the resource compiler can find.
This function is available under Windows only.
@header{wx/utils.h}
*/
wxString wxLoadUserResource(const wxString& resourceName,
const wxString& resourceType = "TEXT");
/**
@deprecated Replaced by wxWindow::Close(). See the
@ref overview_windowdeletion "window deletion overview".
Tells the system to delete the specified object when all other events have
been processed. In some environments, it is necessary to use this instead
of deleting a frame directly with the delete operator, because some GUIs
will still send events to a deleted window.
@header{wx/utils.h}
*/
void wxPostDelete(wxObject* object);
/**
Under X only, sets the current display name. This is the X host and display
name such as "colonsay:0.0", and the function indicates which display
should be used for creating windows from this point on. Setting the display
within an application allows multiple displays to be used.
@see wxGetDisplayName()
@header{wx/utils.h}
*/
void wxSetDisplayName(const wxString& displayName);
/**
Strips any menu codes from @a str and returns the result.
By default, the functions strips both the mnemonics character (@c '&')
which is used to indicate a keyboard shortkey, and the accelerators, which
are used only in the menu items and are separated from the main text by the
@c \t (TAB) character. By using @a flags of @c wxStrip_Mnemonics or
@c wxStrip_Accel to strip only the former or the latter part, respectively.
Notice that in most cases wxMenuItem::GetLabelFromText() or
wxControl::GetLabelText() can be used instead.
@header{wx/utils.h}
*/
wxString wxStripMenuCodes(const wxString& str, int flags = wxStrip_All);
//@}
/** /**
This function returns the "user id" also known as "login name" under Unix This function returns the "user id" also known as "login name" under Unix
i.e. something like "jsmith". It uniquely identifies the current user (on i.e. something like "jsmith". It uniquely identifies the current user (on
@@ -242,63 +455,6 @@ wxString wxGetUserId();
*/ */
bool wxGetUserId(char* buf, int sz); bool wxGetUserId(char* buf, int sz);
/**
Returns battery state as one of @c wxBATTERY_NORMAL_STATE,
@c wxBATTERY_LOW_STATE, @c wxBATTERY_CRITICAL_STATE,
@c wxBATTERY_SHUTDOWN_STATE or @c wxBATTERY_UNKNOWN_STATE.
@c wxBATTERY_UNKNOWN_STATE is also the default on platforms where
this feature is not implemented (currently everywhere but MS Windows).
@header{wx/utils.h}
*/
wxBatteryState wxGetBatteryState();
/**
@deprecated
This function is obsolete, please use wxWindow::FindWindowByName() instead.
Find a window by its name (as given in a window constructor or Create()
function call). If @a parent is @NULL, the search will start from all
top-level frames and dialog boxes; if non-@NULL, the search will be limited
to the given window hierarchy. The search is recursive in both cases. If
no such named window is found, wxFindWindowByLabel() is called.
@header{wx/utils.h}
*/
wxWindow* wxFindWindowByName(const wxString& name, wxWindow* parent = NULL);
/**
This function is deprecated as the ids generated by it can conflict with the
ids defined by the user code, use @c wxID_ANY to assign ids which are
guaranteed to not conflict with the user-defined ids for the controls and menu
items you create instead of using this function.
Generates an integer identifier unique to this run of the program.
@header{wx/utils.h}
*/
long wxNewId();
/**
Ensures that ids subsequently generated by @b NewId do not clash with
the given @b id.
@header{wx/utils.h}
*/
void wxRegisterId(long id);
/**
For normal keys, returns @true if the specified key is currently down.
For togglable keys (Caps Lock, Num Lock and Scroll Lock), returns
@true if the key is toggled such that its LED indicator is lit. There is
currently no way to test whether togglable keys are up or down.
Even though there are virtual key codes defined for mouse buttons, they
cannot be used with this function currently.
@header{wx/utils.h}
*/
bool wxGetKeyState(wxKeyCode key);
/** /**
Returns the string containing the description of the current platform in a Returns the string containing the description of the current platform in a
user-readable form. For example, this function may return strings like user-readable form. For example, this function may return strings like
@@ -338,57 +494,6 @@ void wxMilliSleep(unsigned long milliseconds);
*/ */
void wxMicroSleep(unsigned long microseconds); void wxMicroSleep(unsigned long microseconds);
/**
Find a menu item identifier associated with the given frame's menu bar.
@header{wx/utils.h}
*/
int wxFindMenuItemId(wxFrame* frame, const wxString& menuString,
const wxString& itemString);
/**
This function enables or disables all top level windows. It is used by
::wxSafeYield.
@header{wx/utils.h}
*/
void wxEnableTopLevelWindows(bool enable = true);
/**
Strips any menu codes from @a str and returns the result.
By default, the functions strips both the mnemonics character (@c '')
which is used to indicate a keyboard shortkey, and the accelerators, which are
used only in the menu items and are separated from the main text by the
@c \t (TAB) character. By using @a flags of
@c wxStrip_Mnemonics or @c wxStrip_Accel to strip only the former
or the latter part, respectively.
Notice that in most cases
wxMenuItem::GetLabelFromText or
wxControl::GetLabelText can be used instead.
@header{wx/utils.h}
*/
wxString wxStripMenuCodes(const wxString& str,
int flags = wxStrip_All);
/**
Open the @a url in user's default browser. If @a flags parameter contains
@c wxBROWSER_NEW_WINDOW flag, a new window is opened for the URL
(currently this is only supported under Windows). The @a url may also be a
local file path (with or without @c file:// prefix), if it doesn't
correspond to an existing file and the URL has no scheme @c http:// is
prepended to it by default.
Returns @true if the application was successfully launched.
Note that for some configurations of the running user, the application which
is launched to open the given URL may be URL-dependent (e.g. a browser may be
used for
local URLs while another one may be used for remote URLs).
@header{wx/utils.h}
*/
bool wxLaunchDefaultBrowser(const wxString& url, int flags = 0);
/** /**
Executes a command in an interactive shell window. If no command is Executes a command in an interactive shell window. If no command is
specified, then just the shell is spawned. specified, then just the shell is spawned.
@@ -419,60 +524,6 @@ wxOperatingSystemId wxGetOsVersion(int* major = NULL,
*/ */
wxString wxGetFullHostName(); wxString wxGetFullHostName();
/**
Tells the system to delete the specified object when
all other events have been processed. In some environments, it is
necessary to use this instead of deleting a frame directly with the
delete operator, because some GUIs will still send events to a deleted window.
Now obsolete: use wxWindow::Close instead.
@header{wx/utils.h}
*/
void wxPostDelete(wxObject* object);
/**
@b NB: This function is obsolete, please use
wxWindow::FindWindowByLabel instead.
Find a window by its label. Depending on the type of window, the label may be a
window title
or panel item label. If @a parent is @NULL, the search will start from all
top-level
frames and dialog boxes; if non-@NULL, the search will be limited to the given
window hierarchy.
The search is recursive in both cases.
@header{wx/utils.h}
*/
wxWindow* wxFindWindowByLabel(const wxString& label,
wxWindow* parent = NULL);
/**
Returns the mouse position in screen coordinates.
@header{wx/utils.h}
*/
wxPoint wxGetMousePosition();
/**
Loads a user-defined Windows resource as a string. If the resource is found,
the function creates
a new character array and copies the data into it. A pointer to this data is
returned. If unsuccessful, @NULL is returned.
The resource must be defined in the @c .rc file using the following syntax:
@code
myResource TEXT file.ext
@endcode
where @c file.ext is a file that the resource compiler can find.
This function is available under Windows only.
@header{wx/utils.h}
*/
wxString wxLoadUserResource(const wxString& resourceName,
const wxString& resourceType = "TEXT");
/** /**
Returns the amount of free memory in bytes under environments which Returns the amount of free memory in bytes under environments which
support it, and -1 if not supported or failed to perform measurement. support it, and -1 if not supported or failed to perform measurement.
@@ -499,13 +550,6 @@ wxString wxGetHostName();
bool wxGetHostName(char* buf, int sz); bool wxGetHostName(char* buf, int sz);
//@} //@}
/**
Under X only, returns the current display name. See also wxSetDisplayName().
@header{wx/utils.h}
*/
wxString wxGetDisplayName();
/** /**
Returns the home directory for the given user. If the @a user is empty Returns the home directory for the given user. If the @a user is empty
(default value), this function behaves like (default value), this function behaves like
@@ -702,16 +746,6 @@ unsigned long wxGetProcessId();
int wxKill(long pid, int sig = wxSIGTERM, wxKillError rc = NULL, int wxKill(long pid, int sig = wxSIGTERM, wxKillError rc = NULL,
int flags = 0); int flags = 0);
/**
Returns the current state of the mouse. Returns a wxMouseState
instance that contains the current position of the mouse pointer in
screen coordinates, as well as boolean values indicating the up/down
status of the mouse buttons and the modifier keys.
@header{wx/utils.h}
*/
wxMouseState wxGetMouseState();
//@{ //@{
/** /**
Copies the user's email address into the supplied buffer, by Copies the user's email address into the supplied buffer, by
@@ -743,17 +777,3 @@ void wxSleep(int secs);
*/ */
bool wxIsPlatformLittleEndian(); bool wxIsPlatformLittleEndian();
/**
Under X only, sets the current display name. This is the X host and display
name such
as "colonsay:0.0", and the function indicates which display should be used for
creating
windows from this point on. Setting the display within an application allows
multiple
displays to be used.
See also wxGetDisplayName().
@header{wx/utils.h}
*/
void wxSetDisplayName(const wxString& displayName);

27
interface/window.h
View File

@@ -2613,27 +2613,32 @@ public:
// Global functions/macros // Global functions/macros
// ============================================================================ // ============================================================================
/** /** @ingroup group_funcmacro_misc */
Find the deepest window at the given mouse position in screen coordinates, //@{
returning the window if found, or @NULL if not.
*/
wxWindow* wxFindWindowAtPoint(const wxPoint& pt);
/** /**
Find the deepest window at the mouse pointer position, returning the window Find the deepest window at the mouse pointer position, returning the window
and current pointer position in screen coordinates. and current pointer position in screen coordinates.
@header{wx/window.h}
*/ */
wxWindow* wxFindWindowAtPointer(wxPoint& pt); wxWindow* wxFindWindowAtPointer(wxPoint& pt);
/** /**
Gets the currently active window (implemented for MSW and GTK only currently, Gets the currently active window (implemented for MSW and GTK only
always returns @NULL in the other ports). currently, always returns @NULL in the other ports).
@header{wx/window.h}
*/ */
wxWindow* wxGetActiveWindow(); wxWindow* wxGetActiveWindow();
/** /**
Returns the first top level parent of the given window, or in other words, the Returns the first top level parent of the given window, or in other words,
frame or dialog containing it, or @NULL. the frame or dialog containing it, or @NULL.
*/
wxWindow* wxGetTopLevelParent(wxWindow win); @header{wx/window.h}
*/
wxWindow* wxGetTopLevelParent(wxWindow* window);
//@}