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

adjusted indentation with astyle; added Id keyword

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@52383 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Francesco Montorsi
2008-03-08 14:43:31 +00:00
parent aa6ec1d787
commit 7c913512a4
269 changed files with 9052 additions and 9058 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
interface/aboutdlg.h
View File

@@ -44,9 +44,7 @@ class wxAboutDialogInfo
public: public:
/** /**
Default constructor leaves all fields are initially uninitialized, in general Default constructor leaves all fields are initially uninitialized, in general
you should call at least SetVersion(), you should call at least SetVersion(), SetCopyright() and SetDescription().
SetCopyright() and
SetDescription().
*/ */
wxAboutDialogInfo(); wxAboutDialogInfo();
@@ -73,10 +71,10 @@ public:
/** /**
Adds a translator name to be shown in the program credits. Notice that if no Adds a translator name to be shown in the program credits. Notice that if no
translator names are specified explicitely, wxAboutBox translator names are specified explicitely, wxAboutBox will try to use the
will try to use the translation of the string @c translator-credits from translation of the string @c translator-credits from the currently used message
the currently used message catalog -- this can be used to show just the name of catalog -- this can be used to show just the name of the translator of the
the translator of the program in the current language. program in the current language.
@sa SetTranslators() @sa SetTranslators()
*/ */
@@ -90,8 +88,8 @@ public:
void SetArtists(const wxArrayString& artists); void SetArtists(const wxArrayString& artists);
/** /**
Set the short string containing the program copyright information. Notice that Set the short string containing the program copyright information. Notice
any occurrences of @c "(C)" in @e copyright will be replaced by the that any occurrences of @c "(C)" in @e copyright will be replaced by the
copyright symbol (circled C) automatically, which means that you can avoid copyright symbol (circled C) automatically, which means that you can avoid
using this symbol in the program source code which can be problematic, using this symbol in the program source code which can be problematic,
*/ */
@@ -148,16 +146,14 @@ public:
void SetName(const wxString& name); void SetName(const wxString& name);
/** /**
Set the list of translators. Please see Set the list of translators. Please see AddTranslator() for additional
AddTranslator() for additional
discussion. discussion.
*/ */
void SetTranslators(const wxArrayString& translators); void SetTranslators(const wxArrayString& translators);
/** /**
Set the version of the program. The version is in free format, i.e. not Set the version of the program. The version is in free format, i.e. not
necessarily in the @c x.y.z form but it shouldn't contain the "version" necessarily in the @c x.y.z form but it shouldn't contain the "version" word.
word.
*/ */
void SetVersion(const wxString& version); void SetVersion(const wxString& version);
@@ -214,8 +210,7 @@ void wxAboutBox(const wxAboutDialogInfo& info);
supported). supported).
See the @ref overview_sampledialogs "dialogs sample" for an example of about See the @ref overview_sampledialogs "dialogs sample" for an example of about
dialog dialog customization.
customization.
@sa wxAboutDialogInfo @sa wxAboutDialogInfo
*/ */

32
interface/app.h
View File

@@ -627,7 +627,7 @@ public:
default (but it can be changed). default (but it can be changed).
*/ */
void wxLogMessage(const char * formatString, ... ); void wxLogMessage(const char * formatString, ... );
void wxVLogMessage(const char * formatString, va_list argPtr); void wxVLogMessage(const char * formatString, va_list argPtr);
//@} //@}
//@{ //@{
@@ -638,7 +638,7 @@ void wxLogMessage(const char * formatString, ... );
wxLogInfo). wxLogInfo).
*/ */
void wxLogVerbose(const char * formatString, ... ); void wxLogVerbose(const char * formatString, ... );
void wxVLogVerbose(const char * formatString, va_list argPtr); void wxVLogVerbose(const char * formatString, va_list argPtr);
//@} //@}
/** /**
@@ -668,7 +668,7 @@ void wxExit();
the program work. the program work.
*/ */
void wxLogWarning(const char * formatString, ... ); void wxLogWarning(const char * formatString, ... );
void wxVLogWarning(const char * formatString, va_list argPtr); void wxVLogWarning(const char * formatString, va_list argPtr);
//@} //@}
//@{ //@{
@@ -678,7 +678,7 @@ void wxLogWarning(const char * formatString, ... );
function also terminates the program with this exit code. function also terminates the program with this exit code.
*/ */
void wxLogFatalError(const char * formatString, ... ); void wxLogFatalError(const char * formatString, ... );
void wxVLogFatalError(const char * formatString, void wxVLogFatalError(const char * formatString,
va_list argPtr); va_list argPtr);
//@} //@}
@@ -741,7 +741,7 @@ void wxPostEvent(wxEvtHandler * dest, wxEvent& event);
user about it. user about it.
*/ */
void wxLogError(const char * formatString, ... ); void wxLogError(const char * formatString, ... );
void wxVLogError(const char * formatString, va_list argPtr); void wxVLogError(const char * formatString, va_list argPtr);
//@} //@}
//@{ //@{
@@ -792,15 +792,15 @@ void wxLogError(const char * formatString, ... );
wxTraceOleCalls: trace OLE method calls (Win32 only) wxTraceOleCalls: trace OLE method calls (Win32 only)
*/ */
void wxLogTrace(const char * formatString, ... ); void wxLogTrace(const char * formatString, ... );
void wxVLogTrace(const char * formatString, va_list argPtr); void wxVLogTrace(const char * formatString, va_list argPtr);
void wxLogTrace(const char * mask, const char * formatString, void wxLogTrace(const char * mask, const char * formatString,
... ); ... );
void wxVLogTrace(const char * mask, void wxVLogTrace(const char * mask,
const char * formatString, const char * formatString,
va_list argPtr); va_list argPtr);
void wxLogTrace(wxTraceMask mask, const char * formatString, void wxLogTrace(wxTraceMask mask, const char * formatString,
... ); ... );
void wxVLogTrace(wxTraceMask mask, const char * formatString, void wxVLogTrace(wxTraceMask mask, const char * formatString,
va_list argPtr); va_list argPtr);
//@} //@}
@@ -826,7 +826,7 @@ void wxUninitialize();
nothing in release mode (otherwise). nothing in release mode (otherwise).
*/ */
void wxLogDebug(const char * formatString, ... ); void wxLogDebug(const char * formatString, ... );
void wxVLogDebug(const char * formatString, va_list argPtr); void wxVLogDebug(const char * formatString, va_list argPtr);
//@} //@}
/** /**
@@ -852,10 +852,10 @@ wxAppDerivedClass wxGetApp();
*/ */
void wxLogStatus(wxFrame * frame, const char * formatString, void wxLogStatus(wxFrame * frame, const char * formatString,
... ); ... );
void wxVLogStatus(wxFrame * frame, const char * formatString, void wxVLogStatus(wxFrame * frame, const char * formatString,
va_list argPtr); va_list argPtr);
void wxLogStatus(const char * formatString, ... ); void wxLogStatus(const char * formatString, ... );
void wxVLogStatus(const char * formatString, va_list argPtr); void wxVLogStatus(const char * formatString, va_list argPtr);
//@} //@}
/** /**
@@ -905,7 +905,7 @@ bool wxYield();
@sa wxSysErrorCode, wxSysErrorMsg @sa wxSysErrorCode, wxSysErrorMsg
*/ */
void wxLogSysError(const char * formatString, ... ); void wxLogSysError(const char * formatString, ... );
void wxVLogSysError(const char * formatString, void wxVLogSysError(const char * formatString,
va_list argPtr); va_list argPtr);
//@} //@}
@@ -929,7 +929,7 @@ void wxLogSysError(const char * formatString, ... );
@sa wxEntryStart @sa wxEntryStart
*/ */
int wxEntry(int& argc, wxChar ** argv); int wxEntry(int& argc, wxChar ** argv);
int wxEntry(HINSTANCE hInstance, int wxEntry(HINSTANCE hInstance,
HINSTANCE hPrevInstance = @NULL, HINSTANCE hPrevInstance = @NULL,
char * pCmdLine = @NULL, char * pCmdLine = @NULL,
int nCmdShow = SW_SHOWNORMAL); int nCmdShow = SW_SHOWNORMAL);

154
interface/archive.h
View File

@@ -480,110 +480,110 @@ public:
wxArchiveIterator(Arc& arc) { wxArchiveIterator(Arc& arc) {
/* ... */ /* ... */
}; };
@endcode @endcode
The first template parameter should be the type of archive input stream The first template parameter should be the type of archive input stream
(e.g. wxArchiveInputStream) and the (e.g. wxArchiveInputStream) and the
second can either be a pointer to an entry second can either be a pointer to an entry
(e.g. wxArchiveEntry*), or a string/pointer pair (e.g. wxArchiveEntry*), or a string/pointer pair
(e.g. std::pairwxString, wxArchiveEntry*). (e.g. std::pairwxString, wxArchiveEntry*).
The @c wx/archive.h header defines the following typedefs: The @c wx/archive.h header defines the following typedefs:
@code @code
typedef wxArchiveIteratorwxArchiveInputStream wxArchiveIter; typedef wxArchiveIteratorwxArchiveInputStream wxArchiveIter;
typedef wxArchiveIteratorwxArchiveInputStream, typedef wxArchiveIteratorwxArchiveInputStream,
std::pairwxString, wxArchiveEntry* wxArchivePairIter; std::pairwxString, wxArchiveEntry* wxArchivePairIter;
@endcode @endcode
The header for any implementation of this interface should define similar The header for any implementation of this interface should define similar
typedefs for its types, for example in @c wx/zipstrm.h there is: typedefs for its types, for example in @c wx/zipstrm.h there is:
@code @code
typedef wxArchiveIteratorwxZipInputStream wxZipIter; typedef wxArchiveIteratorwxZipInputStream wxZipIter;
typedef wxArchiveIteratorwxZipInputStream, typedef wxArchiveIteratorwxZipInputStream,
std::pairwxString, wxZipEntry* wxZipPairIter; std::pairwxString, wxZipEntry* wxZipPairIter;
@endcode @endcode
Transferring the catalogue of an archive @e arc to a vector @e cat, Transferring the catalogue of an archive @e arc to a vector @e cat,
can then be done something like this: can then be done something like this:
@code @code
std::vectorwxArchiveEntry* cat((wxArchiveIter)arc, wxArchiveIter()); std::vectorwxArchiveEntry* cat((wxArchiveIter)arc, wxArchiveIter());
@endcode @endcode
When the iterator is dereferenced, it gives away ownership of an entry When the iterator is dereferenced, it gives away ownership of an entry
object. So in the above example, when you have finished with @e cat object. So in the above example, when you have finished with @e cat
you must delete the pointers it contains. you must delete the pointers it contains.
If you have smart pointers with normal copy semantics (i.e. not auto_ptr If you have smart pointers with normal copy semantics (i.e. not auto_ptr
or wxScopedPtr), then you can create an iterator or wxScopedPtr), then you can create an iterator
which uses them instead. For example, with a smart pointer class for which uses them instead. For example, with a smart pointer class for
zip entries @e ZipEntryPtr: zip entries @e ZipEntryPtr:
@code @code
typedef std::vectorZipEntryPtr ZipCatalog; typedef std::vectorZipEntryPtr ZipCatalog;
typedef wxArchiveIteratorwxZipInputStream, ZipEntryPtr ZipIter; typedef wxArchiveIteratorwxZipInputStream, ZipEntryPtr ZipIter;
ZipCatalog cat((ZipIter)zip, ZipIter()); ZipCatalog cat((ZipIter)zip, ZipIter());
@endcode @endcode
Iterators that return std::pair objects can be used to Iterators that return std::pair objects can be used to
populate a std::multimap, to allow entries to be looked populate a std::multimap, to allow entries to be looked
up by name. The string is initialised using the wxArchiveEntry object's up by name. The string is initialised using the wxArchiveEntry object's
wxArchiveEntry::GetInternalName function. wxArchiveEntry::GetInternalName function.
@code @code
typedef std::multimapwxString, wxZipEntry* ZipCatalog; typedef std::multimapwxString, wxZipEntry* ZipCatalog;
ZipCatalog cat((wxZipPairIter)zip, wxZipPairIter()); ZipCatalog cat((wxZipPairIter)zip, wxZipPairIter());
@endcode @endcode
Note that this iterator also gives away ownership of an entry Note that this iterator also gives away ownership of an entry
object each time it is dereferenced. So in the above example, when object each time it is dereferenced. So in the above example, when
you have finished with @e cat you must delete the pointers it contains. you have finished with @e cat you must delete the pointers it contains.
Or if you have them, a pair containing a smart pointer can be used Or if you have them, a pair containing a smart pointer can be used
(again @e ZipEntryPtr), no worries about ownership: (again @e ZipEntryPtr), no worries about ownership:
@code @code
typedef std::multimapwxString, ZipEntryPtr ZipCatalog; typedef std::multimapwxString, ZipEntryPtr ZipCatalog;
typedef wxArchiveIteratorwxZipInputStream, typedef wxArchiveIteratorwxZipInputStream,
std::pairwxString, ZipEntryPtr ZipPairIter; std::pairwxString, ZipEntryPtr ZipPairIter;
ZipCatalog cat((ZipPairIter)zip, ZipPairIter()); ZipCatalog cat((ZipPairIter)zip, ZipPairIter());
@endcode @endcode
@library{wxbase} @library{wxbase}
@category{FIXME} @category{FIXME}
@seealso @seealso
wxArchiveEntry, wxArchiveInputStream, wxArchiveOutputStream wxArchiveEntry, wxArchiveInputStream, wxArchiveOutputStream
*/ */
class wxArchiveIterator class wxArchiveIterator
{ {
public: public:
//@{ //@{
/** /**
Construct iterator that returns all the entries in the archive input Construct iterator that returns all the entries in the archive input
stream @e arc. stream @e arc.
*/ */
wxArchiveIterator(); wxArchiveIterator();
wxArchiveIterator(Arc& arc); wxArchiveIterator(Arc& arc);
//@} //@}
/** /**
Returns an entry object from the archive input stream, giving away Returns an entry object from the archive input stream, giving away
ownership. ownership.
*/ */
const T operator*(); const T operator*();
//@{ //@{
/** /**
Position the input iterator at the next entry in the archive input stream. Position the input iterator at the next entry in the archive input stream.
*/ */
wxArchiveIterator operator++(); wxArchiveIterator operator++();
wxArchiveIterator operator++(int ); wxArchiveIterator operator++(int );
//@} //@}
}; };

5
interface/arrstr.h
View File

@@ -201,7 +201,8 @@ public:
second one. second one.
*/ */
void Sort(bool reverseOrder = @false); void Sort(bool reverseOrder = @false);
Warning: void Sort(CompareFunction compareFunction); Warning:
void Sort(CompareFunction compareFunction);
//@} //@}
/** /**
@@ -251,7 +252,7 @@ public:
*/ */
wxArrayString wxSplit(const wxString& str, const wxChar sep, wxArrayString wxSplit(const wxString& str, const wxChar sep,
const wxChar escape = ' const wxChar escape = '
'); ');
/** /**
Concatenate all lines of the given wxArrayString object using the separator @e Concatenate all lines of the given wxArrayString object using the separator @e

17
interface/atomic.h
View File

@@ -1,15 +1,14 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: atomic.h // Name: atomic.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
This function increments @e value in an atomic manner. This function increments @e value in an atomic manner.
*/ */
void wxAtomicInc(wxAtomicInt& value); void wxAtomicInc(wxAtomicInt& value);

30
interface/base64.h
View File

@@ -1,12 +1,12 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: base64.h // Name: base64.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
//@{ //@{
/** /**
These functions encode the given data using base64. The first of them is the These functions encode the given data using base64. The first of them is the
raw encoding function writing the output string into provided buffer while the raw encoding function writing the output string into provided buffer while the
@@ -32,15 +32,15 @@
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);
wxString wxBase64Encode(const void * src, size_t srcLen); wxString wxBase64Encode(const void * src, size_t srcLen);
wxString wxBase64Encode(const wxMemoryBuffer& buf); 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.
*/ */
size_t wxBase64DecodedSize(size_t srcLen); size_t wxBase64DecodedSize(size_t srcLen);
@@ -100,11 +100,11 @@ size_t wxBase64Decode(void * dst, size_t dstLen,
size_t srcLen = wxNO_LEN, size_t srcLen = wxNO_LEN,
wxBase64DecodeMode mode = wxBase64DecodeMode_Strict, wxBase64DecodeMode mode = wxBase64DecodeMode_Strict,
size_t posErr = @NULL); size_t posErr = @NULL);
wxMemoryBuffer wxBase64Decode(const char * src, wxMemoryBuffer wxBase64Decode(const char * src,
size_t srcLen = wxNO_LEN, size_t srcLen = wxNO_LEN,
wxBase64DecodeMode mode = wxBase64DecodeMode_Strict, wxBase64DecodeMode mode = wxBase64DecodeMode_Strict,
size_t posErr = @NULL); size_t posErr = @NULL);
wxMemoryBuffer wxBase64Decode(const wxString& src, wxMemoryBuffer wxBase64Decode(const wxString& src,
wxBase64DecodeMode mode = wxBase64DecodeMode_Strict, wxBase64DecodeMode mode = wxBase64DecodeMode_Strict,
size_t posErr = @NULL); size_t posErr = @NULL);
//@} //@}

20
interface/chartype.h
View File

@@ -1,12 +1,12 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: chartype.h // Name: chartype.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
//@{ //@{
/** /**
wxT() is a macro which can be used with character and string literals (in other wxT() is a macro which can be used with character and string literals (in other
words, @c 'x' or @c "foo") to automatically convert them to Unicode in words, @c 'x' or @c "foo") to automatically convert them to Unicode in
@@ -25,11 +25,11 @@
@endcode @endcode
*/ */
wxChar wxT(char ch); wxChar wxT(char ch);
const wxChar * wxT(const char * s); const wxChar * wxT(const char * s);
//@} //@}
//@{ //@{
/** /**
wxS is macro which can be used with character and string literals to either wxS is macro which can be used with character and string literals to either
convert them to wide characters or strings in @c wchar_t-based Unicode convert them to wide characters or strings in @c wchar_t-based Unicode
@@ -42,6 +42,6 @@ wxChar wxT(char ch);
@sa wxT @sa wxT
*/ */
wxStringCharType wxS(char ch); wxStringCharType wxS(char ch);
const wxStringCharType * wxS(const char * s); const wxStringCharType * wxS(const char * s);
//@} //@}

8
interface/choicdlg.h
View File

@@ -231,7 +231,7 @@ int wxGetSingleChoiceIndex(const wxString& message,
bool centre = @true, bool centre = @true,
int width=150, int width=150,
int height=200); int height=200);
int wxGetSingleChoiceIndex(const wxString& message, int wxGetSingleChoiceIndex(const wxString& message,
const wxString& caption, const wxString& caption,
int n, int n,
const wxString& choices[], const wxString& choices[],
@@ -267,7 +267,7 @@ wxString wxGetSingleChoice(const wxString& message,
bool centre = @true, bool centre = @true,
int width=150, int width=150,
int height=200); int height=200);
wxString wxGetSingleChoice(const wxString& message, wxString wxGetSingleChoice(const wxString& message,
const wxString& caption, const wxString& caption,
int n, int n,
const wxString& choices[], const wxString& choices[],
@@ -296,7 +296,7 @@ wxString wxGetSingleChoiceData(const wxString& message,
bool centre = @true, bool centre = @true,
int width=150, int width=150,
int height=200); int height=200);
wxString wxGetSingleChoiceData(const wxString& message, wxString wxGetSingleChoiceData(const wxString& message,
const wxString& caption, const wxString& caption,
int n, int n,
const wxString& choices[], const wxString& choices[],
@@ -334,7 +334,7 @@ size_t wxGetMultipleChoices(wxArrayInt& selections,
bool centre = @true, bool centre = @true,
int width=150, int width=150,
int height=200); int height=200);
size_t wxGetMultipleChoices(wxArrayInt& selections, size_t wxGetMultipleChoices(wxArrayInt& selections,
const wxString& message, const wxString& message,
const wxString& caption, const wxString& caption,
int n, int n,

32
interface/clipboard.h
View File

@@ -1,32 +1,32 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: clipboard.h // Name: clipboard.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
Gets the name of a registered clipboard format, and puts it into the buffer @e Gets the name of a registered clipboard format, and puts it into the buffer @e
formatName which is of maximum formatName which is of maximum
length @e maxCount. @e dataFormat must not specify a predefined clipboard length @e maxCount. @e dataFormat must not specify a predefined clipboard
format. format.
*/ */
bool wxGetClipboardFormatName(int dataFormat, bool wxGetClipboardFormatName(int dataFormat,
const wxString& formatName, const wxString& formatName,
int maxCount); int maxCount);
/** /**
Gets data from the clipboard. Gets data from the clipboard.
@e dataFormat may be one of: @e dataFormat may be one of:
wxCF_TEXT or wxCF_OEMTEXT: returns a pointer to new memory containing a wxCF_TEXT or wxCF_OEMTEXT: returns a pointer to new memory containing a
null-terminated text string. null-terminated text string.
wxCF_BITMAP: returns a new wxBitmap. wxCF_BITMAP: returns a new wxBitmap.
The clipboard must have previously been opened for this call to succeed. The clipboard must have previously been opened for this call to succeed.
*/ */
wxObject * wxGetClipboardData(int dataFormat); wxObject * wxGetClipboardData(int dataFormat);

14
interface/colour.h
View File

@@ -100,13 +100,13 @@ public:
*/ */
wxString GetAsString(long flags); wxString GetAsString(long flags);
wxC2S_NAME wxC2S_CSS_SYNTAX, to obtain wxC2S_NAME wxC2S_CSS_SYNTAX, to obtain
the colour in the "rgb(r,g,b)" or "rgba(r,g,b,a)" syntax 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 (e.g. wxColour(255,0,0,85) - "rgba(255,0,0,0.333)"), and
wxC2S_HTML_SYNTAX, to obtain the colour as "#" followed wxC2S_HTML_SYNTAX, to obtain the colour as "#" followed
by 6 hexadecimal digits (e.g. wxColour(255,0,0) - "#FF0000"). 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 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 the colour has alpha channel (i.e. is non opaque) but
wxC2S_CSS_SYNTAX(); wxC2S_CSS_SYNTAX();
//@} //@}
/** /**

2
interface/config.h
View File

@@ -423,7 +423,7 @@ public:
const wxString& defaultVal); const wxString& defaultVal);
wxString Read(const wxString& key, wxString Read(const wxString& key,
const const
wxString& defaultVal); wxString& defaultVal);
bool Read(const wxString& key, long* l); bool Read(const wxString& key, long* l);
bool Read(const wxString& key, long* l, long defaultVal); bool Read(const wxString& key, long* l, long defaultVal);
bool Read(const wxString& key, double* d); bool Read(const wxString& key, double* d);

36
interface/cpp.h
View File

@@ -1,33 +1,33 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: cpp.h // Name: cpp.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
//@{ //@{
/** /**
These macro return the concatenation of the tokens passed as their arguments. These macro return the concatenation of the tokens passed as their arguments.
Unlike when using the preprocessor @c operator, the arguments undergo Unlike when using the preprocessor @c operator, the arguments undergo
the macro expansion before being concatenated. the macro expansion before being concatenated.
*/ */
wxCONCAT(x1, x2); wxCONCAT(x1, x2);
wxCONCAT3(x1, x2, x3); wxCONCAT3(x1, x2, x3);
wxCONCAT4(x1, x2, x3, x4); wxCONCAT4(x1, x2, x3, x4);
wxCONCAT5(x1, x2, x3, x4, x5); wxCONCAT5(x1, x2, x3, x4, x5);
//@} //@}
/** /**
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.
@sa wxCONCAT @sa wxCONCAT
*/ */
#define wxSTRINGIZE(x) /* implementation is private */ #define wxSTRINGIZE(x) /* implementation is private */

2
interface/datetime.h
View File

@@ -1194,7 +1194,7 @@ public:
Same as @ref settm() Set. Same as @ref settm() Set.
*/ */
wxDateTime operator(const struct tm& tm); wxDateTime operator(const struct tm& tm);
}; };
/** /**

36
interface/debug.h
View File

@@ -1,29 +1,29 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: debug.h // Name: debug.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
Will always generate an assert error if this code is reached (in debug mode). Will always generate an assert error if this code is reached (in debug mode).
See also: wxFAIL_MSG See also: wxFAIL_MSG
*/ */
#define wxFAIL() /* implementation is private */ #define wxFAIL() /* implementation is private */
/** /**
This function is called whenever one of debugging macros fails (i.e. condition This function is called whenever one of debugging macros fails (i.e. condition
is @false in an assertion). It is only defined in the debug mode, in release is @false in an assertion). It is only defined in the debug mode, in release
builds the wxCHECK failures don't result in anything. builds the wxCHECK failures don't result in anything.
To override the default behaviour in the debug builds which is to show the user To override the default behaviour in the debug builds which is to show the user
a dialog asking whether he wants to abort the program, continue or continue a dialog asking whether he wants to abort the program, continue or continue
ignoring any subsequent assert failures, you may override ignoring any subsequent assert failures, you may override
wxApp::OnAssertFailure which is called by this function if wxApp::OnAssertFailure which is called by this function if
the global application object exists. the global application object exists.
*/ */
void wxOnAssert(const char * fileName, int lineNumber, void wxOnAssert(const char * fileName, int lineNumber,
const char * func, const char * func,

34
interface/defs.h
View File

@@ -1,25 +1,25 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: defs.h // Name: defs.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
//@{ //@{
/** /**
These macros will swap the bytes of the @e value variable from little These macros will swap the bytes of the @e value variable from little
endian to big endian or vice versa unconditionally, i.e. independently of the endian to big endian or vice versa unconditionally, i.e. independently of the
current platform. current platform.
*/ */
wxInt32 wxINT32_SWAP_ALWAYS(wxInt32 value); wxInt32 wxINT32_SWAP_ALWAYS(wxInt32 value);
wxUint32 wxUINT32_SWAP_ALWAYS(wxUint32 value); wxUint32 wxUINT32_SWAP_ALWAYS(wxUint32 value);
wxInt16 wxINT16_SWAP_ALWAYS(wxInt16 value); wxInt16 wxINT16_SWAP_ALWAYS(wxInt16 value);
wxUint16 wxUINT16_SWAP_ALWAYS(wxUint16 value); wxUint16 wxUINT16_SWAP_ALWAYS(wxUint16 value);
//@} //@}
//@{ //@{
/** /**
This macro will swap the bytes of the @e value variable from little This macro will swap the bytes of the @e value variable from little
endian to big endian or vice versa if the program is compiled on a endian to big endian or vice versa if the program is compiled on a
@@ -30,9 +30,9 @@ wxInt32 wxINT32_SWAP_ALWAYS(wxInt32 value);
data in big-endian format. data in big-endian format.
*/ */
wxInt32 wxINT32_SWAP_ON_LE(wxInt32 value); wxInt32 wxINT32_SWAP_ON_LE(wxInt32 value);
wxUint32 wxUINT32_SWAP_ON_LE(wxUint32 value); wxUint32 wxUINT32_SWAP_ON_LE(wxUint32 value);
wxInt16 wxINT16_SWAP_ON_LE(wxInt16 value); wxInt16 wxINT16_SWAP_ON_LE(wxInt16 value);
wxUint16 wxUINT16_SWAP_ON_LE(wxUint16 value); wxUint16 wxUINT16_SWAP_ON_LE(wxUint16 value);
//@} //@}
/** /**
@@ -100,9 +100,9 @@ wxInt32 wxINT32_SWAP_ON_LE(wxInt32 value);
data in little-endian (for example Intel i386) format. data in little-endian (for example Intel i386) format.
*/ */
wxInt32 wxINT32_SWAP_ON_BE(wxInt32 value); wxInt32 wxINT32_SWAP_ON_BE(wxInt32 value);
wxUint32 wxUINT32_SWAP_ON_BE(wxUint32 value); wxUint32 wxUINT32_SWAP_ON_BE(wxUint32 value);
wxInt16 wxINT16_SWAP_ON_BE(wxInt16 value); wxInt16 wxINT16_SWAP_ON_BE(wxInt16 value);
wxUint16 wxUINT16_SWAP_ON_BE(wxUint16 value); wxUint16 wxUINT16_SWAP_ON_BE(wxUint16 value);
//@} //@}
/** /**

2
interface/file.h
View File

@@ -279,7 +279,7 @@ public:
*/ */
size_t Read(void* buffer, size_t count); size_t Read(void* buffer, size_t count);
Parameters Return value Parameters Return value
The number of bytes read, or the symbol wxInvalidOffset(); The number of bytes read, or the symbol wxInvalidOffset();
//@} //@}
/** /**

6
interface/filefn.h
View File

@@ -212,7 +212,7 @@ time_t wxFileModificationTime(const wxString& filename);
temporary storage that should not be deallocated. temporary storage that should not be deallocated.
*/ */
wxString wxFileNameFromPath(const wxString& path); wxString wxFileNameFromPath(const wxString& path);
char * wxFileNameFromPath(char * path); char * wxFileNameFromPath(char * path);
//@} //@}
/** /**
@@ -343,7 +343,7 @@ wxString wxFindFirstFile(const wxString& spec, int flags = 0);
@endcode @endcode
*/ */
wxFileKind wxGetFileKind(int fd); wxFileKind wxGetFileKind(int fd);
wxFileKind wxGetFileKind(FILE * fp); wxFileKind wxGetFileKind(FILE * fp);
//@} //@}
//@{ //@{
@@ -353,7 +353,7 @@ wxFileKind wxGetFileKind(int fd);
instead. instead.
*/ */
char * wxGetTempFileName(const wxString& prefix, char * buf=@NULL); char * wxGetTempFileName(const wxString& prefix, char * buf=@NULL);
bool wxGetTempFileName(const wxString& prefix, wxString& buf); bool wxGetTempFileName(const wxString& prefix, wxString& buf);
//@} //@}
/** /**

6
interface/gdicmn.h
View File

@@ -773,7 +773,7 @@ public:
*/ */
void wxClientDisplayRect(int * x, int * y, int * width, void wxClientDisplayRect(int * x, int * y, int * width,
int * height); int * height);
wxRect wxGetClientDisplayRect(); wxRect wxGetClientDisplayRect();
//@} //@}
//@{ //@{
@@ -781,7 +781,7 @@ void wxClientDisplayRect(int * x, int * y, int * width,
Returns the display size in pixels. Returns the display size in pixels.
*/ */
void wxDisplaySize(int * width, int * height); void wxDisplaySize(int * width, int * height);
wxSize wxGetDisplaySize(); wxSize wxGetDisplaySize();
//@} //@}
//@{ //@{
@@ -789,7 +789,7 @@ void wxDisplaySize(int * width, int * height);
Returns the display size in millimeters. Returns the display size in millimeters.
*/ */
void wxDisplaySizeMM(int * width, int * height); void wxDisplaySizeMM(int * width, int * height);
wxSize wxGetDisplaySizeMM(); wxSize wxGetDisplaySizeMM();
//@} //@}
/** /**

2
interface/htmllbox.h
View File

@@ -211,7 +211,7 @@ public:
const wxValidator& validator = wxDefaultValidator, const wxValidator& validator = wxDefaultValidator,
const wxString& name = "simpleHtmlListBox"); const wxString& name = "simpleHtmlListBox");
See also See also
wxSimpleHtmlListBox::Create wxSimpleHtmlListBox::Create
wxSimpleHtmlListBox(); wxSimpleHtmlListBox();
//@} //@}

20
interface/init.h
View File

@@ -1,25 +1,25 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: init.h // Name: init.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
Free resources allocated by a successful call to wxEntryStart. Free resources allocated by a successful call to wxEntryStart.
*/ */
void wxEntryCleanup(); void wxEntryCleanup();
//@{ //@{
/** /**
(notice that under Windows CE platform, and only there, the type of (notice that under Windows CE platform, and only there, the type of
@e pCmdLine is @c wchar_t *, otherwise it is @c char *, even in @e pCmdLine is @c wchar_t *, otherwise it is @c char *, even in
Unicode build). Unicode build).
*/ */
bool wxEntryStart(int& argc, wxChar ** argv); bool wxEntryStart(int& argc, wxChar ** argv);
bool wxEntryStart(HINSTANCE hInstance, bool wxEntryStart(HINSTANCE hInstance,
HINSTANCE hPrevInstance = @NULL, HINSTANCE hPrevInstance = @NULL,
char * pCmdLine = @NULL, char * pCmdLine = @NULL,
int nCmdShow = SW_SHOWNORMAL); int nCmdShow = SW_SHOWNORMAL);

6
interface/intl.h
View File

@@ -561,8 +561,8 @@ public:
of wxGetTranslation. of wxGetTranslation.
*/ */
#define const wxString wxPLURAL(const wxString& sing, #define const wxString wxPLURAL(const wxString& sing,
const wxString& plur, const wxString& plur,
size_t n) /* implementation is private */ size_t n) /* implementation is private */
/** /**
This macro doesn't do anything in the program code -- it simply expands to the This macro doesn't do anything in the program code -- it simply expands to the
@@ -653,7 +653,7 @@ public:
*/ */
const wxString wxGetTranslation(const wxString& str, const wxString wxGetTranslation(const wxString& str,
const wxString& domain = wxEmptyString); const wxString& domain = wxEmptyString);
const wxString wxGetTranslation(const wxString& str, const wxString wxGetTranslation(const wxString& str,
const wxString& strPlural, const wxString& strPlural,
size_t n, size_t n,
const wxString& domain = wxEmptyString); const wxString& domain = wxEmptyString);

46
interface/link.h
View File

@@ -1,34 +1,34 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: link.h // Name: link.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
This macro can be used in conjunction with the This macro can be used in conjunction with the
wxFORCE_LINK_MODULE macro to force wxFORCE_LINK_MODULE macro to force
the linker to include in its output a specific object file. the linker to include in its output a specific object file.
In particular, you should use this macro in the source file which you want In particular, you should use this macro in the source file which you want
to force for inclusion. The @c moduleName needs to be a name not already to force for inclusion. The @c moduleName needs to be a name not already
in use in other @c wxFORCE_LINK_THIS_MODULE macros, but is not required in use in other @c wxFORCE_LINK_THIS_MODULE macros, but is not required
to be e.g. the same name of the source file (even if it's a good choice). to be e.g. the same name of the source file (even if it's a good choice).
*/ */
#define wxFORCE_LINK_THIS_MODULE() /* implementation is private */ #define wxFORCE_LINK_THIS_MODULE() /* implementation is private */
/** /**
This macro can be used in conjunction with the This macro can be used in conjunction with the
wxFORCE_LINK_THIS_MODULE macro to force wxFORCE_LINK_THIS_MODULE macro to force
the linker to include in its output a specific object file. the linker to include in its output a specific object file.
In particular, you should use this macro in a source file which you know In particular, you should use this macro in a source file which you know
for sure is linked in the output (e.g. the source file containing the "main()" for sure is linked in the output (e.g. the source file containing the "main()"
of your app). The @c moduleName is the name of the module you want to of your app). The @c moduleName is the name of the module you want to
forcefully link forcefully link
(i.e. the name you used in the relative wxFORCE_LINK_THIS_MODULE macro. (i.e. the name you used in the relative wxFORCE_LINK_THIS_MODULE macro.
*/ */
#define wxFORCE_LINK_MODULE() /* implementation is private */ #define wxFORCE_LINK_MODULE() /* implementation is private */

52
interface/listctrl.h
View File

@@ -755,56 +755,56 @@ public:
wxLIST_MASK_TEXT wxLIST_MASK_TEXT
The m_text field is valid. The m_text field is valid.
wxLIST_MASK_IMAGE wxLIST_MASK_IMAGE
The m_image field is valid. The m_image field is valid.
wxLIST_MASK_DATA wxLIST_MASK_DATA
The m_data field is valid. The m_data field is valid.
wxLIST_MASK_WIDTH wxLIST_MASK_WIDTH
The m_width field is valid. The m_width field is valid.
wxLIST_MASK_FORMAT wxLIST_MASK_FORMAT
The m_format field is valid. The m_format field is valid.
@@ -818,67 +818,67 @@ The m_stateMask and m_state members take flags from the following:
wxLIST_STATE_DONTCARE wxLIST_STATE_DONTCARE
Don't care what the state is. Win32 only. Don't care what the state is. Win32 only.
wxLIST_STATE_DROPHILITED wxLIST_STATE_DROPHILITED
The item is highlighted to receive a drop event. Win32 only. The item is highlighted to receive a drop event. Win32 only.
wxLIST_STATE_FOCUSED wxLIST_STATE_FOCUSED
The item has the focus. The item has the focus.
wxLIST_STATE_SELECTED wxLIST_STATE_SELECTED
The item is selected. The item is selected.
wxLIST_STATE_CUT wxLIST_STATE_CUT
The item is in the cut state. Win32 only. The item is in the cut state. Win32 only.
The wxListItem object can also contain item-specific colour and font The wxListItem object can also contain item-specific colour and font
information: for this you need to call one of SetTextColour(), information: for this you need to call one of SetTextColour(),
SetBackgroundColour() or SetFont() functions on it passing it the colour/font SetBackgroundColour() or SetFont() functions on it passing it the colour/font
to use. If the colour/font is not specified, the default list control to use. If the colour/font is not specified, the default list control
colour/font is used. colour/font is used.
long SetItem(long index, int col, const wxString& label, long SetItem(long index, int col, const wxString& label,
int imageId = -1); int imageId = -1);
//@} //@}

19
interface/math.h
View File

@@ -1,16 +1,15 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: math.h // Name: math.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
Returns a non-zero value if @e x is neither infinite nor NaN (not a number), Returns a non-zero value if @e x is neither infinite nor NaN (not a number),
returns 0 otherwise. returns 0 otherwise.
*/ */
int wxFinite(double x); int wxFinite(double x);

31
interface/numdlg.h
View File

@@ -1,22 +1,22 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: numdlg.h // Name: numdlg.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
Shows a dialog asking the user for numeric input. The dialogs title is set to Shows a dialog asking the user for numeric input. The dialogs title is set to
@e caption, it contains a (possibly) multiline @e message above the @e caption, it contains a (possibly) multiline @e message above the
single line @e prompt and the zone for entering the number. single line @e prompt and the zone for entering the number.
The number entered must be in the range @e min..@e max (both of which The number entered must be in the range @e min..@e max (both of which
should be positive) and @e value is the initial value of it. If the user should be positive) and @e value is the initial value of it. If the user
enters an invalid value or cancels the dialog, the function will return -1. enters an invalid value or cancels the dialog, the function will return -1.
Dialog is centered on its @e parent unless an explicit position is given in Dialog is centered on its @e parent unless an explicit position is given in
@e pos. @e pos.
*/ */
long wxGetNumberFromUser(const wxString& message, long wxGetNumberFromUser(const wxString& message,
const wxString& prompt, const wxString& prompt,
@@ -28,4 +28,3 @@ long wxGetNumberFromUser(const wxString& message,
const wxPoint& pos = wxDefaultPosition); const wxPoint& pos = wxDefaultPosition);

40
interface/platform.h
View File

@@ -1,35 +1,35 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: platform.h // Name: platform.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
Same as wxCHECK_VERSION but also checks that Same as wxCHECK_VERSION but also checks that
@c wxSUBRELEASE_NUMBER is at least @e subrel. @c wxSUBRELEASE_NUMBER is at least @e subrel.
*/ */
#define bool wxCHECK_VERSION_FULL(major, minor, release, subrel) /* implementation is private */ #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 This is a macro which evaluates to @true if the current wxWidgets version is at
least major.minor.release. least major.minor.release.
For example, to test if the program is compiled with wxWidgets 2.2 or higher, For example, to test if the program is compiled with wxWidgets 2.2 or higher,
the following can be done: the following can be done:
@code @code
wxString s; wxString s;
#if wxCHECK_VERSION(2, 2, 0) #if wxCHECK_VERSION(2, 2, 0)
if ( s.StartsWith("foo") ) if ( s.StartsWith("foo") )
#else // replacement code for old version #else // replacement code for old version
if ( strncmp(s, "foo", 3) == 0 ) if ( strncmp(s, "foo", 3) == 0 )
#endif #endif
{ {
... ...
} }
@endcode @endcode
*/ */
#define bool wxCHECK_VERSION(major, minor, release) /* implementation is private */ #define bool wxCHECK_VERSION(major, minor, release) /* implementation is private */

28
interface/scopeguard.h
View File

@@ -1,23 +1,23 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: scopeguard.h // Name: scopeguard.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
//@{ //@{
/** /**
This family of macros is similar to wxON_BLOCK_EXIT This family of macros is similar to wxON_BLOCK_EXIT
but calls a method of the given object instead of a free function. but calls a method of the given object instead of a free function.
*/ */
wxON_BLOCK_EXIT_OBJ0(obj, method); wxON_BLOCK_EXIT_OBJ0(obj, method);
wxON_BLOCK_EXIT_OBJ1(obj, method, p1); wxON_BLOCK_EXIT_OBJ1(obj, method, p1);
wxON_BLOCK_EXIT_OBJ2(obj, method, p1, p2); wxON_BLOCK_EXIT_OBJ2(obj, method, p1, p2);
//@} //@}
//@{ //@{
/** /**
This family of macros allows to ensure that the global function @e func 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 with 0, 1, 2 or more parameters (up to some implementaton-defined limit) is
@@ -35,8 +35,8 @@
@sa wxON_BLOCK_EXIT_OBJ @sa wxON_BLOCK_EXIT_OBJ
*/ */
wxON_BLOCK_EXIT0(func); wxON_BLOCK_EXIT0(func);
wxON_BLOCK_EXIT1(func, p1); wxON_BLOCK_EXIT1(func, p1);
wxON_BLOCK_EXIT2(func, p1, p2); wxON_BLOCK_EXIT2(func, p1, p2);
//@} //@}

37
interface/stockitem.h
View File

@@ -1,29 +1,28 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: stockitem.h // Name: stockitem.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
Returns label that should be used for given @e id element. Returns label that should be used for given @e 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 getting labels without accelerator char code like for toolbar useful for getting labels without accelerator char code like for toolbar
tooltip or tooltip 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 building labels for wxMenuItem for building labels for wxMenuItem
*/ */
wxString wxGetStockLabel(wxWindowID id, bool withCodes = @true, wxString wxGetStockLabel(wxWindowID id, bool withCodes = @true,
const wxString& accelerator = wxEmptyString); const wxString& accelerator = wxEmptyString);

14
interface/stream.h
View File

@@ -238,12 +238,12 @@ public:
*/ */
void SetBufferIO(char* buffer_start, char* buffer_end); void SetBufferIO(char* buffer_start, char* buffer_end);
Remarks See also Remarks See also
wxStreamBuffer constructor wxStreamBuffer constructor
wxStreamBuffer::Fixed wxStreamBuffer::Fixed
wxStreamBuffer::Flushable wxStreamBuffer::Flushable
void SetBufferIO(size_t bufsize); void SetBufferIO(size_t bufsize);
//@} //@}
/** /**
@@ -657,9 +657,9 @@ public:
*/ */
wxInputStream Read(void * buffer, size_t size); wxInputStream Read(void * buffer, size_t size);
Warning Return value Warning Return value
This function returns a reference on the current object, so the user can test This function returns a reference on the current object, so the user can test
any states of the stream right away. any states of the stream right away.
wxInputStream& Read(wxOutputStream& stream_out); wxInputStream& Read(wxOutputStream& stream_out);
//@} //@}
/** /**

4
interface/string.h
View File

@@ -1301,7 +1301,7 @@ public:
See also: wxFromString. See also: wxFromString.
*/ */
wxString wxToString(const wxColour& col); wxString wxToString(const wxColour& col);
wxString wxToString(const wxFont& col); wxString wxToString(const wxFont& col);
//@} //@}
//@{ //@{
@@ -1310,6 +1310,6 @@ wxString wxToString(const wxColour& col);
See also: wxToString. See also: wxToString.
*/ */
bool wxFromString(const wxString& str, wxColour* col); bool wxFromString(const wxString& str, wxColour* col);
bool wxFromString(const wxString& str, wxFont* col); bool wxFromString(const wxString& str, wxFont* col);
//@} //@}

20
interface/treectrl.h
View File

@@ -427,7 +427,8 @@ public:
Returns the font of the item label. Returns the font of the item label.
*/ */
wxTreeItemData* GetItemData(const wxTreeItemId& item); wxTreeItemData* GetItemData(const wxTreeItemId& item);
See also wxPython note: wxPython provides the following shortcut method: See also wxPython note:
wxPython provides the following shortcut method:
@@ -435,13 +436,13 @@ public:
GetPyData(item) GetPyData(item)
Returns the Python Object Returns the Python Object
associated with the wxTreeItemData for the given item Id. associated with the wxTreeItemData for the given item Id.
@@ -449,7 +450,7 @@ associated with the wxTreeItemData for the given item Id.
wxFont GetItemFont(const wxTreeItemId& item); wxFont GetItemFont(const wxTreeItemId& item);
//@} //@}
/** /**
@@ -800,13 +801,14 @@ wxFont GetItemFont(const wxTreeItemId& item);
is implemented internally). is implemented internally).
*/ */
void SetItemData(const wxTreeItemId& item, wxTreeItemData* data); void SetItemData(const wxTreeItemId& item, wxTreeItemData* data);
wxPython note: SetPyData(item, obj) wxPython note:
SetPyData(item, obj)
Associate the given Python Associate the given Python
Object with the wxTreeItemData for the given item Id. Object with the wxTreeItemData for the given item Id.
@@ -814,7 +816,7 @@ Object with the wxTreeItemData for the given item Id.
void SetItemDropHighlight(const wxTreeItemId& item, void SetItemDropHighlight(const wxTreeItemId& item,
bool highlight = @true); bool highlight = @true);
//@} //@}

200
interface/utils.h
View File

@@ -107,7 +107,7 @@ wxPowerType wxGetPowerType();
@sa wxGetUserName @sa wxGetUserName
*/ */
wxString wxGetUserId(); wxString wxGetUserId();
bool wxGetUserId(char * buf, int sz); bool wxGetUserId(char * buf, int sz);
//@} //@}
/** /**
@@ -243,19 +243,19 @@ void wxMicroSleep(unsigned long microseconds);
*/ */
void wxInfoMessageBox(wxWindow ( parent = @NULL); void wxInfoMessageBox(wxWindow ( parent = @NULL);
/** /**
Find a menu item identifier associated with the given frame's menu bar. Find a menu item identifier associated with the given frame's menu bar.
*/ */
int wxFindMenuItemId(wxFrame * frame, const wxString& menuString, int wxFindMenuItemId(wxFrame * frame, const wxString& menuString,
const wxString& itemString); const wxString& itemString);
/** /**
This function enables or disables all top level windows. It is used by This function enables or disables all top level windows. It is used by
::wxSafeYield. ::wxSafeYield.
*/ */
void wxEnableTopLevelWindows(bool enable = @true); void wxEnableTopLevelWindows(bool enable = @true);
/** /**
Strips any menu codes from @e str and returns the result. Strips any menu codes from @e str and returns the result.
By default, the functions strips both the mnemonics character (@c '') By default, the functions strips both the mnemonics character (@c '')
@@ -268,22 +268,22 @@ void wxEnableTopLevelWindows(bool enable = @true);
Notice that in most cases Notice that in most cases
wxMenuItem::GetLabelFromText or wxMenuItem::GetLabelFromText or
wxControl::GetLabelText can be used instead. wxControl::GetLabelText can be used instead.
*/ */
wxString wxStripMenuCodes(const wxString& str, wxString wxStripMenuCodes(const wxString& str,
int flags = wxStrip_All); int flags = wxStrip_All);
/** /**
@b NB: This function is now obsolete, please use wxLogError @b NB: This function is now obsolete, please use wxLogError
instead. instead.
Displays @e msg and continues. This writes to standard error under Displays @e msg and continues. This writes to standard error under
Unix, and pops up a message box under Windows. Used for internal Unix, and pops up a message box under Windows. Used for internal
wxWidgets errors. See also wxFatalError. wxWidgets errors. See also wxFatalError.
*/ */
void wxError(const wxString& msg, void wxError(const wxString& msg,
const wxString& title = "wxWidgets Internal Error"); const wxString& title = "wxWidgets Internal Error");
/** /**
Open the @e url in user's default browser. If @e flags parameter contains Open the @e url in user's default browser. If @e flags parameter contains
@c wxBROWSER_NEW_WINDOW flag, a new window is opened for the URL @c wxBROWSER_NEW_WINDOW flag, a new window is opened for the URL
(currently this is only supported under Windows). The @e url may also be a (currently this is only supported under Windows). The @e url may also be a
@@ -297,55 +297,55 @@ void wxError(const wxString& msg,
is launched to open the given URL may be URL-dependent (e.g. a browser may be is launched to open the given URL may be URL-dependent (e.g. a browser may be
used for used for
local URLs while another one may be used for remote URLs). local URLs while another one may be used for remote URLs).
*/ */
bool wxLaunchDefaultBrowser(const wxString& url, int flags = 0); 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.
See also wxExecute, @ref overview_sampleexec "Exec sample". See also wxExecute, @ref overview_sampleexec "Exec sample".
*/ */
bool wxShell(const wxString& command = @NULL); bool wxShell(const wxString& command = @NULL);
/** /**
Gets the version and the operating system ID for currently running OS. Gets the version and the operating system ID for currently running OS.
See wxPlatformInfo for more details about wxOperatingSystemId. See wxPlatformInfo for more details about wxOperatingSystemId.
@sa ::wxGetOsDescription, wxPlatformInfo @sa ::wxGetOsDescription, wxPlatformInfo
*/ */
wxOperatingSystemId wxGetOsVersion(int * major = @NULL, wxOperatingSystemId wxGetOsVersion(int * major = @NULL,
int * minor = @NULL); int * minor = @NULL);
/** /**
Returns the FQDN (fully qualified domain host name) or an empty string on Returns the FQDN (fully qualified domain host name) or an empty string on
error. error.
@sa wxGetHostName @sa wxGetHostName
*/ */
wxString wxGetFullHostName(); wxString wxGetFullHostName();
/** /**
Changes the cursor to the given cursor for all windows in the application. Changes the cursor to the given cursor for all windows in the application.
Use wxEndBusyCursor to revert the cursor back Use wxEndBusyCursor to revert the cursor back
to its previous state. These two calls can be nested, and a counter to its previous state. These two calls can be nested, and a counter
ensures that only the outer calls take effect. ensures that only the outer calls take effect.
See also wxIsBusy, wxBusyCursor. See also wxIsBusy, wxBusyCursor.
*/ */
void wxBeginBusyCursor(wxCursor * cursor = wxHOURGLASS_CURSOR); void wxBeginBusyCursor(wxCursor * cursor = wxHOURGLASS_CURSOR);
/** /**
Tells the system to delete the specified object when Tells the system to delete the specified object when
all other events have been processed. In some environments, it is all other events have been processed. In some environments, it is
necessary to use this instead of deleting a frame directly with the 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. delete operator, because some GUIs will still send events to a deleted window.
Now obsolete: use wxWindow::Close instead. Now obsolete: use wxWindow::Close instead.
*/ */
void wxPostDelete(wxObject * object); void wxPostDelete(wxObject * object);
/** /**
@b NB: This function is obsolete, please use @b NB: This function is obsolete, please use
wxWindow::FindWindowByLabel instead. wxWindow::FindWindowByLabel instead.
@@ -356,26 +356,26 @@ void wxPostDelete(wxObject * object);
frames and dialog boxes; if non-@NULL, the search will be limited to the given frames and dialog boxes; if non-@NULL, the search will be limited to the given
window hierarchy. window hierarchy.
The search is recursive in both cases. The search is recursive in both cases.
*/ */
wxWindow * wxFindWindowByLabel(const wxString& label, wxWindow * wxFindWindowByLabel(const wxString& label,
wxWindow * parent=@NULL); wxWindow * parent=@NULL);
/** /**
This function is similar to wxYield, except that it disables the user input to This function is similar to wxYield, except that it disables the user input to
all program windows before calling wxYield and re-enables it again all program windows before calling wxYield and re-enables it again
afterwards. If @e win is not @NULL, this window will remain enabled, afterwards. If @e win is not @NULL, this window will remain enabled,
allowing the implementation of some limited user interaction. allowing the implementation of some limited user interaction.
Returns the result of the call to ::wxYield. Returns the result of the call to ::wxYield.
*/ */
bool wxSafeYield(wxWindow* win = @NULL, bool onlyIfNeeded = @false); bool wxSafeYield(wxWindow* win = @NULL, bool onlyIfNeeded = @false);
/** /**
Returns the mouse position in screen coordinates. Returns the mouse position in screen coordinates.
*/ */
wxPoint wxGetMousePosition(); wxPoint wxGetMousePosition();
/** /**
Loads a user-defined Windows resource as a string. If the resource is found, Loads a user-defined Windows resource as a string. If the resource is found,
the function creates the function creates
a new character array and copies the data into it. A pointer to this data is a new character array and copies the data into it. A pointer to this data is
@@ -389,28 +389,28 @@ wxPoint wxGetMousePosition();
where @c file.ext is a file that the resource compiler can find. where @c file.ext is a file that the resource compiler can find.
This function is available under Windows only. This function is available under Windows only.
*/ */
wxString wxLoadUserResource(const wxString& resourceName, wxString wxLoadUserResource(const wxString& resourceName,
const wxString& resourceType="TEXT"); 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.
*/ */
wxMemorySize wxGetFreeMemory(); wxMemorySize wxGetFreeMemory();
/** /**
This is a macro defined as @c getenv() or its wide char version in Unicode This is a macro defined as @c getenv() or its wide char version in Unicode
mode. mode.
Note that under Win32 it may not return correct value for the variables set Note that under Win32 it may not return correct value for the variables set
with wxSetEnv, use wxGetEnv function with wxSetEnv, use wxGetEnv function
instead. instead.
*/ */
wxChar * wxGetEnv(const wxString& var); wxChar * wxGetEnv(const wxString& var);
//@{ //@{
/** /**
Copies the current host machine's name into the supplied buffer. Please note Copies the current host machine's name into the supplied buffer. Please note
that the returned name is @e not fully qualified, i.e. it does not include that the returned name is @e not fully qualified, i.e. it does not include
the domain name. the domain name.
@@ -424,44 +424,44 @@ wxChar * wxGetEnv(const wxString& var);
if successful, @false otherwise. if successful, @false otherwise.
@sa wxGetFullHostName @sa wxGetFullHostName
*/ */
wxString wxGetHostName(); wxString wxGetHostName();
bool wxGetHostName(char * buf, int sz); bool wxGetHostName(char * buf, int sz);
//@} //@}
/** /**
Returns the current value of the environment variable @e var in @e value. Returns the current value of the environment variable @e var in @e value.
@e value may be @NULL if you just want to know if the variable exists @e value may be @NULL if you just want to know if the variable exists
and are not interested in its value. and are not interested in its value.
Returns @true if the variable exists, @false otherwise. Returns @true if the variable exists, @false otherwise.
*/ */
bool wxGetEnv(const wxString& var, wxString * value); bool wxGetEnv(const wxString& var, wxString * value);
/** /**
Under X only, returns the current display name. See also wxSetDisplayName. Under X only, returns the current display name. See also wxSetDisplayName.
*/ */
wxString wxGetDisplayName(); wxString wxGetDisplayName();
/** /**
Ring the system bell. Ring the system bell.
Note that this function is categorized as a GUI one and so is not thread-safe. Note that this function is categorized as a GUI one and so is not thread-safe.
*/ */
void wxBell(); void wxBell();
/** /**
Returns the home directory for the given user. If the @e user is empty Returns the home directory for the given user. If the @e user is empty
(default value), this function behaves like (default value), this function behaves like
wxGetHomeDir i.e. returns the current user home wxGetHomeDir i.e. returns the current user home
directory. directory.
If the home directory couldn't be determined, an empty string is returned. If the home directory couldn't be determined, an empty string is returned.
*/ */
wxString wxGetUserHome(const wxString& user = ""); wxString wxGetUserHome(const wxString& user = "");
//@{ //@{
/** /**
@b wxPerl note: In wxPerl this function is called @c Wx::ExecuteStdoutStderr @b wxPerl note: In wxPerl this function is called @c Wx::ExecuteStdoutStderr
and it only takes the @c command argument, and it only takes the @c command argument,
and returns a 3-element list @c ( status, output, errors ), where and returns a 3-element list @c ( status, output, errors ), where
@@ -550,8 +550,8 @@ wxString wxGetUserHome(const wxString& user = "");
An optional pointer to wxProcess An optional pointer to wxProcess
@sa wxShell, wxProcess, @ref overview_sampleexec "Exec sample". @sa wxShell, wxProcess, @ref overview_sampleexec "Exec sample".
*/ */
long wxExecute(const wxString& command, int sync = wxEXEC_ASYNC, long wxExecute(const wxString& command, int sync = wxEXEC_ASYNC,
wxProcess * callback = @NULL); wxProcess * callback = @NULL);
wxPerl note: long wxExecute(char ** argv, wxPerl note: long wxExecute(char ** argv,
int flags = wxEXEC_ASYNC, int flags = wxEXEC_ASYNC,
@@ -565,12 +565,12 @@ long wxExecute(const wxString& command, int sync = wxEXEC_ASYNC,
int flags = 0); int flags = 0);
//@} //@}
/** /**
Returns a string representing the current date and time. Returns a string representing the current date and time.
*/ */
wxString wxNow(); wxString wxNow();
/** /**
Returns @true if the operating system the program is running under is 64 bit. Returns @true if the operating system the program is running under is 64 bit.
The check is performed at run-time and may differ from the value available at The check is performed at run-time and may differ from the value available at
compile-time (at compile-time you can just check if @c sizeof(void*)==8) compile-time (at compile-time you can just check if @c sizeof(void*)==8)
@@ -582,17 +582,17 @@ wxString wxNow();
fact fact
that there isn't always a standard way to do a reliable check on the OS that there isn't always a standard way to do a reliable check on the OS
architecture. architecture.
*/ */
bool wxIsPlatform64Bit(); bool wxIsPlatform64Bit();
/** /**
Returns the number uniquely identifying the current process in the system. Returns the number uniquely identifying the current process in the system.
If an error occurs, 0 is returned. If an error occurs, 0 is returned.
*/ */
unsigned long wxGetProcessId(); unsigned long wxGetProcessId();
/** /**
Equivalent to the Unix kill function: send the given signal @e sig to the Equivalent to the Unix kill function: send the given signal @e sig to the
process with PID @e pid. The valid signal values are process with PID @e pid. The valid signal values are
@code @code
@@ -641,63 +641,63 @@ unsigned long wxGetProcessId();
to wxExecute. to wxExecute.
@sa wxProcess::Kill, wxProcess::Exists, @ref overview_sampleexec "Exec sample" @sa wxProcess::Kill, wxProcess::Exists, @ref overview_sampleexec "Exec sample"
*/ */
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 Returns the current state of the mouse. Returns a wxMouseState
instance that contains the current position of the mouse pointer in instance that contains the current position of the mouse pointer in
screen coordinates, as well as boolean values indicating the up/down screen coordinates, as well as boolean values indicating the up/down
status of the mouse buttons and the modifier keys. status of the mouse buttons and the modifier keys.
*/ */
wxMouseState wxGetMouseState(); wxMouseState wxGetMouseState();
/** /**
Returns @true if between two wxBeginBusyCursor and Returns @true if between two wxBeginBusyCursor and
wxEndBusyCursor calls. wxEndBusyCursor calls.
See also wxBusyCursor. See also wxBusyCursor.
*/ */
bool wxIsBusy(); bool wxIsBusy();
//@{ //@{
/** /**
Copies the user's email address into the supplied buffer, by Copies the user's email address into the supplied buffer, by
concatenating the values returned by wxGetFullHostName concatenating the values returned by wxGetFullHostName
and wxGetUserId. and wxGetUserId.
Returns @true if successful, @false otherwise. Returns @true if successful, @false otherwise.
*/ */
wxString wxGetEmailAddress(); wxString wxGetEmailAddress();
bool wxGetEmailAddress(char * buf, int sz); bool wxGetEmailAddress(char * buf, int sz);
//@} //@}
/** /**
Sleeps for the specified number of seconds. Sleeps for the specified number of seconds.
*/ */
void wxSleep(int secs); void wxSleep(int secs);
/** /**
Sets the value of the environment variable @e var (adding it if necessary) Sets the value of the environment variable @e var (adding it if necessary)
to @e value. to @e value.
Returns @true on success. Returns @true on success.
@sa wxUnsetEnv @sa wxUnsetEnv
*/ */
bool wxSetEnv(const wxString& var, const wxString& value); bool wxSetEnv(const wxString& var, const wxString& value);
/** /**
Returns @true if the current platform is little endian (instead of big Returns @true if the current platform is little endian (instead of big
endian). endian).
The check is performed at run-time. The check is performed at run-time.
@sa @ref overview_byteordermacros "Byte order macros" @sa @ref overview_byteordermacros "Byte order macros"
*/ */
bool wxIsPlatformLittleEndian(); bool wxIsPlatformLittleEndian();
/** /**
Under X only, sets the current display name. This is the X host and display Under X only, sets the current display name. This is the X host and display
name such name such
as "colonsay:0.0", and the function indicates which display should be used for as "colonsay:0.0", and the function indicates which display should be used for
@@ -707,6 +707,6 @@ bool wxIsPlatformLittleEndian();
displays to be used. displays to be used.
See also wxGetDisplayName. See also wxGetDisplayName.
*/ */
void wxSetDisplayName(const wxString& displayName); void wxSetDisplayName(const wxString& displayName);

34
interface/wxcrt.h
View File

@@ -1,28 +1,28 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: wxcrt.h // Name: wxcrt.h
// Purpose: documentation for global functions // Purpose: documentation for global functions
// Author: wxWidgets team // Author: wxWidgets team
// RCS-ID: $Id$ // RCS-ID: $Id$
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
/** /**
Returns a negative value, 0, or positive value if @e p1 is less than, equal Returns a negative value, 0, or positive value if @e p1 is less than, equal
to or greater than @e p2. The comparison is case-sensitive. to or greater than @e p2. The comparison is case-sensitive.
This function complements the standard C function @e stricmp() which performs This function complements the standard C function @e stricmp() which performs
case-insensitive comparison. case-insensitive comparison.
*/ */
int wxStrcmp(const char * p1, const char * p2); int wxStrcmp(const char * p1, const char * p2);
/** /**
@b NB: This function is obsolete, use wxString instead. @b NB: This function is obsolete, use wxString instead.
A macro defined as: A macro defined as:
@code @code
#define wxStringEq(s1, s2) (s1 && s2 && (strcmp(s1, s2) == 0)) #define wxStringEq(s1, s2) (s1 && s2 && (strcmp(s1, s2) == 0))
@endcode @endcode
*/ */
bool wxStringEq(const wxString& s1, const wxString& s2); bool wxStringEq(const wxString& s1, const wxString& s2);