/////////////////////////////////////////////////////////////////////////////
// Name: access.h
-// Purpose: documentation for wxAccessible class
+// Purpose: interface of wxAccessible
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
void SetWindow(wxWindow* window);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: animate.h
-// Purpose: documentation for wxAnimationCtrl class
+// Purpose: interface of wxAnimationCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{animationctrl.png}
- @seealso
- wxAnimation
+ @see wxAnimation
*/
class wxAnimationCtrl : public wxControl
{
};
+
/**
@class wxAnimation
@wxheader{animate.h}
@category{FIXME}
@stdobjects
- Objects:
- wxNullAnimation
+ ::Objects:, ::wxNullAnimation,
- @seealso
- wxAnimationCtrl
+ @see wxAnimationCtrl
*/
class wxAnimation : public wxGDIObject
{
*/
wxAnimation operator =(const wxAnimation& brush);
};
+
+
+/**
+ FIXME
+*/
+wxAnimation Objects:
+;
+
+/**
+ FIXME
+*/
+wxAnimation wxNullAnimation;
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: app.h
-// Purpose: documentation for wxApp class
+// Purpose: interface of wxApp
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{appmanagement}
- @seealso
- @ref overview_wxappoverview "wxApp overview"
+ @see @ref overview_wxappoverview "wxApp overview"
*/
class wxApp : public wxEvtHandler
{
page headers and so on while the other one should be only used internally, e.g.
for the file names or configuration file keys.
By default, returns the same string as GetAppName().
- This function is new since wxWidgets version 2.9.0
+
+ @wxsince{2.9.0}
*/
wxString GetAppDisplayName() const;
page headers and so on while the other one should be only used internally, e.g.
for the file names or configuration file keys.
By default, returns the same string as GetVendorName().
- This function is new since wxWidgets version 2.9.0
+
+ @wxsince{2.9.0}
*/
wxString GetVendorDisplayName() const;
/**
This function is called when an assert failure occurs, i.e. the condition
- specified in wxASSERT macro evaluated to @false.
+ specified in wxASSERT() macro evaluated to @false.
It is only called in debug mode (when @c __WXDEBUG__ is defined) as
asserts are not left in the release code at all.
The base class version shows the default assert failure dialog box proposing to
This function may be called if something fatal happens: an unhandled
exception under Win32 or a a fatal signal under Unix, for example. However,
this will not happen by default: you have to explicitly call
- wxHandleFatalExceptions to enable this.
+ wxHandleFatalExceptions() to enable this.
Generally speaking, this function should only show a message to the user and
return. You may attempt to save unsaved data but this is not guaranteed to
work and, in fact, probably won't.
- @see wxHandleFatalExceptions
+ @see wxHandleFatalExceptions()
*/
void OnFatalException();
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/**
This is used in headers to create a forward declaration of the
- wxGetApp function implemented by
- wxIMPLEMENT_APP. It creates the declaration
+ wxGetApp() function implemented by
+ wxIMPLEMENT_APP(). It creates the declaration
@c className wxGetApp(void).
Example:
//@{
/**
- Like wxLogError, but also
+ Like wxLogError(), but also
terminates the program with the exit code 3. Using @e abort() standard
function also terminates the program with this exit code.
*/
IMPLEMENT_APP(MyApp)
@endcode
- See also DECLARE_APP.
+ See also DECLARE_APP().
*/
#define IMPLEMENT_APP() /* implementation is private */
Returns the error code from the last system call. This function uses
@c errno on Unix platforms and @c GetLastError under Win32.
- @see wxSysErrorMsg, wxLogSysError
+ @see wxSysErrorMsg(), wxLogSysError()
*/
unsigned long wxSysErrorCode();
/**
Returns the error message corresponding to the given system error code. If
@a errCode is 0 (default), the last error code (as returned by
- wxSysErrorCode) is used.
+ wxSysErrorCode()) is used.
- @see wxSysErrorCode, wxLogSysError
+ @see wxSysErrorCode(), wxLogSysError()
*/
const wxChar* wxSysErrorMsg(unsigned long errCode = 0);
/**
This function is for use in console (wxBase) programs only. It must be called
- once for each previous successful call to wxInitialize.
+ once for each previous successful call to wxInitialize().
*/
void wxUninitialize();
/**
This function doesn't exist in wxWidgets but it is created by using
- the IMPLEMENT_APP macro. Thus, before using it
+ the IMPLEMENT_APP() macro. Thus, before using it
anywhere but in the same module where this macro is used, you must make it
- available using DECLARE_APP.
+ available using DECLARE_APP().
The advantage of using this function compared to directly using the global
wxTheApp pointer is that the latter is of type @c wxApp * and so wouldn't
allow you to access the functions specific to your application class but not
@c main() function before calling any other wxWidgets functions.
If the function returns @false the initialization could not be performed,
in this case the library cannot be used and
- wxUninitialize shouldn't be called neither.
+ wxUninitialize() shouldn't be called neither.
This function may be called several times but
- wxUninitialize must be called for each successful
+ wxUninitialize() must be called for each successful
call to this function.
*/
bool wxInitialize();
/**
This is used in headers to create a forward declaration of the
- wxGetApp function implemented by
- IMPLEMENT_APP. It creates the declaration
+ wxGetApp() function implemented by
+ IMPLEMENT_APP(). It creates the declaration
@c className wxGetApp(void).
Example:
on the platform) and the corresponding error message. The second form
of this function takes the error code explicitly as the first argument.
- @see wxSysErrorCode, wxSysErrorMsg
+ @see wxSysErrorCode(), wxSysErrorMsg()
*/
void wxLogSysError(const char* formatString, ... );
void wxVLogSysError(const char* formatString,
function wxApp::CleanUp. For example, if exiting from
an MFC application that also uses wxWidgets:
- @see wxEntryStart
+ @see wxEntryStart()
*/
int wxEntry(int& argc, wxChar** argv);
int wxEntry(HINSTANCE hInstance,
/////////////////////////////////////////////////////////////////////////////
// Name: apptrait.h
-// Purpose: documentation for wxAppTraits class
+// Purpose: interface of wxAppTraits
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxappoverview "wxApp overview", wxApp
+ @see @ref overview_wxappoverview "wxApp overview", wxApp
*/
class wxAppTraits
{
/**
Called by wxWidgets to create the default configuration object for the
application. The default version creates a registry-based
- wxRegConfig class under MSW and
+ wxRegConfig() class under MSW and
wxFileConfig under all other platforms. The
wxApp wxApp::GetAppName and
wxApp::GetVendorName methods are used to determine the
*/
virtual bool ShowAssertDialog(const wxString& msg);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: archive.h
-// Purpose: documentation for wxArchiveInputStream class
+// Purpose: interface of wxArchiveInputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", wxArchiveEntry,
+ @see @ref overview_wxarc "Archive formats such as zip", wxArchiveEntry,
wxArchiveOutputStream
*/
class wxArchiveInputStream : public wxFilterInputStream
};
+
/**
@class wxArchiveOutputStream
@wxheader{archive.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", wxArchiveEntry,
+ @see @ref overview_wxarc "Archive formats such as zip", wxArchiveEntry,
wxArchiveInputStream
*/
class wxArchiveOutputStream : public wxFilterOutputStream
};
+
/**
@class wxArchiveEntry
@wxheader{archive.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", @ref overview_wxarcgeneric
- "Generic archive programming", wxArchiveInputStream, wxArchiveOutputStream, wxArchiveNotifier
+ @see @ref overview_wxarc "Archive formats such as zip", @ref
+ overview_wxarcgeneric "Generic archive programming", wxArchiveInputStream, wxArchiveOutputStream, wxArchiveNotifier
*/
class wxArchiveEntry : public wxObject
{
//@{
/**
- Sets the notifier for this entry.
+ Sets the notifier() for this entry.
Whenever the wxArchiveInputStream updates
this entry, it will then invoke the associated
notifier's wxArchiveNotifier::OnEntryUpdated
};
+
/**
@class wxArchiveClassFactory
@wxheader{archive.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", @ref overview_wxarcgeneric
- "Generic archive programming", wxArchiveEntry, wxArchiveInputStream, wxArchiveOutputStream, wxFilterClassFactory
+ @see @ref overview_wxarc "Archive formats such as zip", @ref
+ overview_wxarcgeneric "Generic archive programming", wxArchiveEntry, wxArchiveInputStream, wxArchiveOutputStream, wxFilterClassFactory
*/
class wxArchiveClassFactory : public wxObject
{
};
+
/**
@class wxArchiveNotifier
@wxheader{archive.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarcnoseek "Archives on non-seekable streams", wxArchiveEntry,
- wxArchiveInputStream, wxArchiveOutputStream
+ @see @ref overview_wxarcnoseek "Archives on non-seekable streams",
+ wxArchiveEntry, wxArchiveInputStream, wxArchiveOutputStream
*/
class wxArchiveNotifier
{
};
+
/**
@class wxArchiveIterator
@wxheader{archive.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxArchiveEntry, wxArchiveInputStream, wxArchiveOutputStream
+ @see wxArchiveEntry, wxArchiveInputStream, wxArchiveOutputStream
*/
class wxArchiveIterator
{
wxArchiveIterator operator++(int );
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: arrstr.h
-// Purpose: documentation for wxArrayString class
+// Purpose: interface of wxArrayString
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
doesn't take more space than a C array @e wxString[] type (wxArrayString
uses its knowledge of internals of wxString class to achieve this).
- This class is used in the same way as other dynamic arrays,
+ This class is used in the same way as other dynamic arrays(),
except that no @e WX_DEFINE_ARRAY declaration is needed for it. When a
string is added or inserted in the array, a copy of the string is created, so
the original string may be safely deleted (e.g. if it was a @e wxChar *
@library{wxbase}
@category{containers}
- @seealso
- wxArray, wxString, @ref overview_wxstringoverview "wxString overview"
+ @see wxArray, wxString, @ref overview_wxstringoverview "wxString overview"
*/
class wxArrayString : public wxArray
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
Note that empty tokens will be generated if there are two or more adjacent
separators.
- @see wxJoin
+ @see wxJoin()
*/
wxArrayString wxSplit(const wxString& str, const wxChar sep,
const wxChar escape = '
occurrence of @e sep
in the strings contained in @a arr before joining them which is necessary
in order to be able to recover the original array contents from the string
- later using wxSplit.
+ later using wxSplit().
*/
wxString wxJoin(const wxArrayString& arr, const wxChar sep,
const wxChar escape = '\');
/////////////////////////////////////////////////////////////////////////////
// Name: artprov.h
-// Purpose: documentation for wxArtProvider class
+// Purpose: interface of wxArtProvider
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
is used when
requesting a resource from it. The ID is represented by wxArtID type and can
have one of these predefined values (you can see bitmaps represented by these
- constants in the artprov sample):
+ constants in the artprov() sample):
wxART_ERROR
wxART_QUESTION
@library{wxcore}
@category{FIXME}
- @seealso
- See the artprov sample for an example of wxArtProvider usage.
+ @see See the artprov() sample for an example of wxArtProvider usage.
*/
class wxArtProvider : public wxObject
{
GetBitmap()
returns identical bitmap for different @e client values!
- @see See the artprov sample for an example of wxArtProvider usage.
+ @see See the artprov() sample for an example of wxArtProvider usage.
*/
is used when
requesting a resource from it. The ID is represented by wxArtID type and can
have one of these predefined values (you can see bitmaps represented by these
- constants in the artprov sample):
+ constants in the artprov() sample):
wxART_ERROR
wxART_QUESTION
*/
static bool Remove(wxArtProvider* provider);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: atomic.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// Name: aui/aui.h
-// Purpose: documentation for wxAuiManager class
+// Purpose: interface of wxAuiManager
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{aui}
- @seealso
- wxAuiPaneInfo, wxAuiDockArt
+ @see wxAuiPaneInfo, wxAuiDockArt
*/
class wxAuiManager : public wxEvtHandler
{
};
+
/**
@class wxAuiPaneInfo
@headerfile aui.h wx/aui/aui.h
@library{wxbase}
@category{aui}
- @seealso
- wxAuiManager, wxAuiDockArt
+ @see wxAuiManager, wxAuiDockArt
*/
class wxAuiPaneInfo
{
*/
wxAuiPaneInfo& operator operator=(const wxAuiPaneInfo& c);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: aui/auibook.h
-// Purpose: documentation for wxAuiNotebook class
+// Purpose: interface of wxAuiNotebook
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxAuiTabArt
@headerfile auibook.h wx/aui/auibook.h
int ShowWindowList(wxWindow* wnd, const wxArrayString& items,
int active_idx);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: aui/dockart.h
-// Purpose: documentation for wxAuiDockArt class
+// Purpose: interface of wxAuiDockArt
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxaui}
@category{aui}
- @seealso
- wxAuiManager, wxAuiPaneInfo
+ @see wxAuiManager, wxAuiPaneInfo
*/
class wxAuiDockArt
{
*/
virtual void SetMetric(int id, int new_val);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: base64.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
other ones return the output as wxString. There is no error return for these
functions except for the first one which returns @c wxCONV_FAILED if the
output buffer is too small. To allocate the buffer of the correct size, use
- wxBase64EncodedSize or call this function with
+ wxBase64EncodedSize() or call this function with
@a dst set to @NULL -- it will then return the necessary buffer size.
@param dst
/**
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
-buffer to be passed to wxBase64Decode.
+buffer to be passed to wxBase64Decode().
*/
size_t wxBase64DecodedSize(size_t srcLen);
/**
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
- to wxBase64Encode.
+ to wxBase64Encode().
*/
size_t wxBase64EncodedSize(size_t len);
These function decode a Base64-encoded string. The first version is a raw
decoding function and decodes the data into the provided buffer @a dst of
the given size @e dstLen. An error is returned if the buffer is not large
- enough -- that is not at least wxBase64DecodedSize(srcLen)
+ enough -- that is not at least wxBase64DecodedSize(srcLen)()
bytes. The second version allocates memory internally and returns it as
wxMemoryBuffer and is recommended for normal use.
The first version returns the number of bytes written to the buffer or the
/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.h
-// Purpose: documentation for wxBitmapHandler class
+// Purpose: interface of wxBitmapHandler
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@class wxBitmapHandler
@wxheader{bitmap.h}
- Overview
+ Overview()
This is the base class for implementing bitmap file loading/saving, and bitmap
creation from data.
@library{wxcore}
@category{FIXME}
- @seealso
- wxBitmap, wxIcon, wxCursor
+ @see wxBitmap, wxIcon, wxCursor
*/
class wxBitmapHandler : public wxObject
{
};
+
/**
@class wxBitmap
@wxheader{bitmap.h}
@category{gdi}
@stdobjects
- Objects:
- wxNullBitmap
+ ::Objects:, ::wxNullBitmap,
- @seealso
- @ref overview_wxbitmapoverview "wxBitmap overview", @ref
+ @see @ref overview_wxbitmapoverview "wxBitmap overview", @ref
overview_supportedbitmapformats "supported bitmap file formats", wxDC::Blit, wxIcon, wxCursor, wxBitmap, wxMemoryDC
*/
class wxBitmap : public wxGDIObject
};
+/**
+ FIXME
+*/
+wxBitmap Objects:
+;
+
+/**
+ FIXME
+*/
+wxBitmap wxNullBitmap;
+
+
+
+
/**
@class wxMask
@wxheader{bitmap.h}
@library{wxcore}
@category{gdi}
- @seealso
- wxBitmap, wxDC::Blit, wxMemoryDC
+ @see wxBitmap, wxDC::Blit, wxMemoryDC
*/
class wxMask : public wxObject
{
bool Create(const wxBitmap& bitmap, int index);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: bmpbuttn.h
-// Purpose: documentation for wxBitmapButton class
+// Purpose: interface of wxBitmapButton
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@wxheader{bmpbuttn.h}
A bitmap button is a control that contains a bitmap.
- It may be placed on a @ref overview_wxdialog "dialog box" or panel, or indeed
+ It may be placed on a @ref overview_wxdialog "dialog box" or panel(), or indeed
almost any other window.
@beginStyleTable
@category{ctrl}
@appearance{bitmapbutton.png}
- @seealso
- wxButton
+ @see wxButton
*/
class wxBitmapButton : public wxButton
{
/**
Sets the bitmap to be shown when the mouse is over the button.
- This function is new since wxWidgets version 2.7.0 and the hover bitmap is
+
+ @wxsince{2.7.0} and the hover bitmap is
currently only supported in wxMSW.
@see GetBitmapHover()
*/
void SetBitmapSelected(const wxBitmap& bitmap);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: bmpcbox.h
-// Purpose: documentation for wxBitmapComboBox class
+// Purpose: interface of wxBitmapComboBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{bitmapcombobox.png}
- @seealso
- wxComboBox, wxChoice, wxOwnerDrawnComboBox, wxCommandEvent
+ @see wxComboBox, wxChoice, wxOwnerDrawnComboBox, wxCommandEvent
*/
class wxBitmapComboBox : public wxComboBox
{
*/
void SetItemBitmap(unsigned int n, const wxBitmap& bitmap);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: brush.h
-// Purpose: documentation for wxBrush class
+// Purpose: interface of wxBrush
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{gdi}
@stdobjects
- Objects:
- wxNullBrush
- Pointers:
- wxBLUE_BRUSH
+ ::Objects:, ::wxNullBrush, ::Pointers:, ::wxBLUE_BRUSH, ::wxGREEN_BRUSH,
+ ::wxWHITE_BRUSH, ::wxBLACK_BRUSH, ::wxGREY_BRUSH, ::wxMEDIUM_GREY_BRUSH, ::wxLIGHT_GREY_BRUSH, ::wxTRANSPARENT_BRUSH, ::wxCYAN_BRUSH, ::wxRED_BRUSH,
- wxGREEN_BRUSH
-
- wxWHITE_BRUSH
-
- wxBLACK_BRUSH
-
- wxGREY_BRUSH
-
- wxMEDIUM_GREY_BRUSH
-
- wxLIGHT_GREY_BRUSH
-
- wxTRANSPARENT_BRUSH
-
- wxCYAN_BRUSH
-
- wxRED_BRUSH
-
- @seealso
- wxBrushList, wxDC, wxDC::SetBrush
+ @see wxBrushList, wxDC, wxDC::SetBrush
*/
class wxBrush : public wxGDIObject
{
*/
bool operator ==(const wxBrush& brush);
};
+
+
+/**
+ FIXME
+*/
+wxBrush Objects:
+;
+
+/**
+ FIXME
+*/
+wxBrush wxNullBrush;
+
+/**
+ FIXME
+*/
+wxBrush Pointers:
+;
+
+/**
+ FIXME
+*/
+wxBrush wxBLUE_BRUSH;
+
+/**
+ FIXME
+*/
+wxBrush wxGREEN_BRUSH;
+
+/**
+ FIXME
+*/
+wxBrush wxWHITE_BRUSH;
+
+/**
+ FIXME
+*/
+wxBrush wxBLACK_BRUSH;
+
+/**
+ FIXME
+*/
+wxBrush wxGREY_BRUSH;
+
+/**
+ FIXME
+*/
+wxBrush wxMEDIUM_GREY_BRUSH;
+
+/**
+ FIXME
+*/
+wxBrush wxLIGHT_GREY_BRUSH;
+
+/**
+ FIXME
+*/
+wxBrush wxTRANSPARENT_BRUSH;
+
+/**
+ FIXME
+*/
+wxBrush wxCYAN_BRUSH;
+
+/**
+ FIXME
+*/
+wxBrush wxRED_BRUSH;
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: buffer.h
-// Purpose: documentation for wxMemoryBuffer class
+// Purpose: interface of wxMemoryBuffer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
void UngetWriteBuf(size_t sizeUsed);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: busyinfo.h
-// Purpose: documentation for wxBusyInfo class
+// Purpose: interface of wxBusyInfo
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
~wxBusyInfo();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: button.h
-// Purpose: documentation for wxButton class
+// Purpose: interface of wxButton
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
A button is a control that contains a text string,
and is one of the most common elements of a GUI. It may be placed on a
- @ref overview_wxdialog "dialog box" or panel, or indeed
+ @ref overview_wxdialog "dialog box" or panel(), or indeed
almost any other window.
@beginStyleTable
@category{ctrl}
@appearance{button.png}
- @seealso
- wxBitmapButton
+ @see wxBitmapButton
*/
class wxButton : public wxControl
{
*/
void SetLabel(const wxString& label);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: calctrl.h
-// Purpose: documentation for wxCalendarEvent class
+// Purpose: interface of wxCalendarEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxadv}
@category{events}
- @seealso
- wxCalendarCtrl
+ @see wxCalendarCtrl
*/
class wxCalendarEvent : public wxDateEvent
{
};
+
/**
@class wxCalendarDateAttr
@wxheader{calctrl.h}
@library{wxadv}
@category{misc}
- @seealso
- wxCalendarCtrl
+ @see wxCalendarCtrl
*/
class wxCalendarDateAttr
{
const wxColour GetBackgroundColour() const;
/**
- Returns the border to use for the item with this attribute.
+ Returns the border() to use for the item with this attribute.
*/
wxCalendarDateBorder GetBorder() const;
};
+
/**
@class wxCalendarCtrl
@wxheader{calctrl.h}
@category{ctrl}
@appearance{calendarctrl.png}
- @seealso
- @ref overview_samplecalendar "Calendar sample", wxCalendarDateAttr,
+ @see @ref overview_samplecalendar "Calendar sample", wxCalendarDateAttr,
wxCalendarEvent
*/
class wxCalendarCtrl : public wxControl
/**
Returns one of @c wxCAL_HITTEST_XXX
- constants and fills either @a date or
+ constants() and fills either @a date or
@a wd pointer with the corresponding value depending on the hit test code.
*/
wxCalendarHitTestResult HitTest(const wxPoint& pos,
void SetHolidayColours(const wxColour& colFg,
const wxColour& colBg);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: caret.h
-// Purpose: documentation for wxCaret class
+// Purpose: interface of wxCaret
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{misc}
- @seealso
- wxCaret::GetBlinkTime
+ @see wxCaret::GetBlinkTime
*/
class wxCaret
{
*/
void Show(bool show = true);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: chartype.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
current build, but using it can be beneficial in performance-sensitive code to
do the conversion at compile-time instead.
- @see wxT
+ @see wxT()
*/
wxStringCharType wxS(char ch);
const wxStringCharType* wxS(const char* s);
/////////////////////////////////////////////////////////////////////////////
// Name: checkbox.h
-// Purpose: documentation for wxCheckBox class
+// Purpose: interface of wxCheckBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{checkbox.png}
- @seealso
- wxRadioButton, wxCommandEvent
+ @see wxRadioButton, wxCommandEvent
*/
class wxCheckBox : public wxControl
{
*/
void SetValue(bool state);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: checklst.h
-// Purpose: documentation for wxCheckListBox class
+// Purpose: interface of wxCheckListBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{checklistbox.png}
- @seealso
- wxListBox, wxChoice, wxComboBox, wxListCtrl, wxCommandEvent
+ @see wxListBox, wxChoice, wxComboBox, wxListCtrl, wxCommandEvent
*/
class wxCheckListBox : public wxListBox
{
*/
void Check(int item, bool check = true);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: choicdlg.h
-// Purpose: documentation for wxMultiChoiceDialog class
+// Purpose: interface of wxMultiChoiceDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{cmndlg}
- @seealso
- @ref overview_wxmultichoicedialogoverview "wxMultiChoiceDialog overview",
+ @see @ref overview_wxmultichoicedialogoverview "wxMultiChoiceDialog overview",
wxSingleChoiceDialog
*/
class wxMultiChoiceDialog : public wxDialog
};
+
/**
@class wxSingleChoiceDialog
@wxheader{choicdlg.h}
@library{wxbase}
@category{cmndlg}
- @seealso
- @ref overview_wxsinglechoicedialogoverview "wxSingleChoiceDialog overview",
- wxMultiChoiceDialog
+ @see @ref overview_wxsinglechoicedialogoverview "wxSingleChoiceDialog
+ overview", wxMultiChoiceDialog
*/
class wxSingleChoiceDialog : public wxDialog
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
Pops up a dialog box containing a message, OK/Cancel buttons and a
single-selection listbox. The user may choose an item and press OK to return a
string or Cancel to return the empty string. Use
- wxGetSingleChoiceIndex if empty string is a
+ wxGetSingleChoiceIndex() if empty string is a
valid choice and if you want to be able to detect pressing Cancel reliably.
You may pass the list of strings to choose from either using @e choices
which is an array of @a n strings for the listbox or by using a single
/////////////////////////////////////////////////////////////////////////////
// Name: choice.h
-// Purpose: documentation for wxChoice class
+// Purpose: interface of wxChoice
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{choice.png}
- @seealso
- wxListBox, wxComboBox, wxCommandEvent
+ @see wxListBox, wxComboBox, wxCommandEvent
*/
class wxChoice : public wxControlWithItems
{
That is, while the dropdown list is shown, it returns the currently selected
item in it. When it is not shown, its result is the same as for the other
function.
- This function is new since wxWidgets version 2.6.2 (before this version
+
+ @wxsince{2.6.2} (before this version
wxControlWithItems::GetSelection itself behaved like
this).
*/
*/
void SetColumns(int n = 1);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: choicebk.h
-// Purpose: documentation for wxChoicebook class
+// Purpose: interface of wxChoicebook
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{miscwnd}
- @seealso
- wxBookCtrl, wxNotebook, @ref overview_samplenotebook "notebook sample"
+ @see wxBookCtrl(), wxNotebook, @ref overview_samplenotebook "notebook sample"
*/
class wxChoicebook : public wxBookCtrl overview
{
const wxString& name = wxEmptyStr);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: clipboard.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// Name: clipbrd.h
-// Purpose: documentation for wxClipboard class
+// Purpose: interface of wxClipboard
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dnd}
- @seealso
- @ref overview_wxdndoverview, wxDataObject
+ @see @ref overview_wxdndoverview, wxDataObject
*/
class wxClipboard : public wxObject
{
*/
void UsePrimarySelection(bool primary = true);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: clntdata.h
-// Purpose: documentation for wxClientDataContainer class
+// Purpose: interface of wxClientDataContainer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxEvtHandler, wxClientData
+ @see wxEvtHandler, wxClientData
*/
class wxClientDataContainer
{
};
+
/**
@class wxClientData
@wxheader{clntdata.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxEvtHandler, wxTreeItemData, wxStringClientData, wxClientDataContainer
+ @see wxEvtHandler, wxTreeItemData, wxStringClientData, wxClientDataContainer
*/
class wxClientData
{
};
+
/**
@class wxStringClientData
@wxheader{clntdata.h}
*/
void SetData(const wxString& data);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: clrpicker.h
-// Purpose: documentation for wxColourPickerCtrl class
+// Purpose: interface of wxColourPickerCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{miscpickers}
@appearance{colourpickerctrl.png}
- @seealso
- wxColourDialog, wxColourPickerEvent
+ @see wxColourDialog, wxColourPickerEvent
*/
class wxColourPickerCtrl : public wxPickerBase
{
};
+
/**
@class wxColourPickerEvent
@wxheader{clrpicker.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxColourPickerCtrl
+ @see wxColourPickerCtrl
*/
class wxColourPickerEvent : public wxCommandEvent
{
*/
void SetColour(const wxColour& pos);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: cmdline.h
-// Purpose: documentation for wxCmdLineParser class
+// Purpose: interface of wxCmdLineParser
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{appmanagement}
- @seealso
- wxApp::argc and wxApp::argv, console sample
+ @see wxApp::argc and wxApp::argv, console sample
*/
class wxCmdLineParser
{
*/
void Usage();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: cmdproc.h
-// Purpose: documentation for wxCommand class
+// Purpose: interface of wxCommand
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- Overview
+ @see Overview()
*/
class wxCommand : public wxObject
{
};
+
/**
@class wxCommandProcessor
@wxheader{cmdproc.h}
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_wxcommandprocessoroverview "wxCommandProcessor overview",
+ @see @ref overview_wxcommandprocessoroverview "wxCommandProcessor overview",
wxCommand
*/
class wxCommandProcessor : public wxObject
*/
virtual bool Undo();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: cmndata.h
-// Purpose: documentation for wxFontData class
+// Purpose: interface of wxFontData
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- Overview, wxFont, wxFontDialog
+ @see Overview(), wxFont, wxFontDialog
*/
class wxFontData : public wxObject
{
};
+
/**
@class wxPageSetupDialogData
@wxheader{cmndata.h}
@library{wxcore}
@category{printing}
- @seealso
- @ref overview_printingoverview "Printing framework overview", wxPageSetupDialog
+ @see @ref overview_printingoverview "Printing framework overview",
+ wxPageSetupDialog
*/
class wxPageSetupDialogData : public wxObject
{
};
+
/**
@class wxColourData
@wxheader{cmndata.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxColour, wxColourDialog, @ref overview_wxcolourdialogoverview "wxColourDialog
- overview"
+ @see wxColour, wxColourDialog, @ref overview_wxcolourdialogoverview
+ "wxColourDialog overview"
*/
class wxColourData : public wxObject
{
};
+
/**
@class wxPrintData
@wxheader{cmndata.h}
@library{wxcore}
@category{printing}
- @seealso
- @ref overview_printingoverview "Printing framework overview", wxPrintDialog,
- wxPageSetupDialog, wxPrintDialogData, wxPageSetupDialogData, @ref overview_wxprintdialogoverview "wxPrintDialog Overview", wxPrinterDC, wxPostScriptDC
+ @see @ref overview_printingoverview "Printing framework overview",
+ wxPrintDialog, wxPageSetupDialog, wxPrintDialogData, wxPageSetupDialogData, @ref overview_wxprintdialogoverview "wxPrintDialog Overview", wxPrinterDC, wxPostScriptDC
*/
class wxPrintData : public wxObject
{
};
+
/**
@class wxPrintDialogData
@wxheader{cmndata.h}
@library{wxcore}
@category{printing}
- @seealso
- @ref overview_printingoverview "Printing framework overview", wxPrintDialog,
- @ref overview_wxprintdialogoverview "wxPrintDialog Overview"
+ @see @ref overview_printingoverview "Printing framework overview",
+ wxPrintDialog, @ref overview_wxprintdialogoverview "wxPrintDialog Overview"
*/
class wxPrintDialogData : public wxObject
{
void operator =(const wxPrintDialogData& data);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: collpane.h
-// Purpose: documentation for wxCollapsiblePaneEvent class
+// Purpose: interface of wxCollapsiblePaneEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxCollapsiblePane
+ @see wxCollapsiblePane
*/
class wxCollapsiblePaneEvent : public wxCommandEvent
{
};
+
/**
@class wxCollapsiblePane
@wxheader{collpane.h}
@category{ctrl}
@appearance{collapsiblepane.png}
- @seealso
- wxPanel, wxCollapsiblePaneEvent
+ @see wxPanel, wxCollapsiblePaneEvent
*/
class wxCollapsiblePane : public wxControl
{
*/
bool IsExpanded() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: colordlg.h
-// Purpose: documentation for wxColourDialog class
+// Purpose: interface of wxColourDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{cmndlg}
- @seealso
- @ref overview_wxcolourdialogoverview "wxColourDialog Overview", wxColour,
- wxColourData, wxGetColourFromUser
+ @see @ref overview_wxcolourdialogoverview "wxColourDialog Overview", wxColour,
+ wxColourData, wxGetColourFromUser()
*/
class wxColourDialog : public wxDialog
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: colour.h
-// Purpose: documentation for wxColour class
+// Purpose: interface of wxColour
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{gdi}
@stdobjects
- Objects:
- wxNullColour
- Pointers:
- wxBLACK
+ ::Objects:, ::wxNullColour, ::Pointers:, ::wxBLACK, ::wxWHITE, ::wxRED,
+ ::wxBLUE, ::wxGREEN, ::wxCYAN, ::wxLIGHT_GREY,
- wxWHITE
-
- wxRED
-
- wxBLUE
-
- wxGREEN
-
- wxCYAN
-
- wxLIGHT_GREY
-
- @seealso
- wxColourDatabase, wxPen, wxBrush, wxColourDialog, wxSystemSettings
+ @see wxColourDatabase, wxPen, wxBrush, wxColourDialog, wxSystemSettings
*/
class wxColour : public wxObject
{
/**
is not
specified in flags.
- This function is new since wxWidgets version 2.7.0
+
+ @wxsince{2.7.0}
*/
wxString GetAsString(long flags);
const wxC2S_NAME, to obtain the colour name (e.g.
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).
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 "rgba(r,g,b,a)" syntax (case insensitive)
and the HTML-like syntax (i.e. @c "#" followed by 6 hexadecimal digits
for red, green, blue components).
Returns @true if the conversion was successful, @false otherwise.
- This function is new since wxWidgets version 2.7.0
+
+ @wxsince{2.7.0}
*/
void Set(unsigned char red, unsigned char green,
unsigned char blue,
*/
bool operator ==(const wxColour& colour);
};
+
+
+/**
+ FIXME
+*/
+wxColour Objects:
+;
+
+/**
+ FIXME
+*/
+wxColour wxNullColour;
+
+/**
+ FIXME
+*/
+wxColour Pointers:
+;
+
+/**
+ FIXME
+*/
+wxColour wxBLACK;
+
+/**
+ FIXME
+*/
+wxColour wxWHITE;
+
+/**
+ FIXME
+*/
+wxColour wxRED;
+
+/**
+ FIXME
+*/
+wxColour wxBLUE;
+
+/**
+ FIXME
+*/
+wxColour wxGREEN;
+
+/**
+ FIXME
+*/
+wxColour wxCYAN;
+
+/**
+ FIXME
+*/
+wxColour wxLIGHT_GREY;
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: combo.h
-// Purpose: documentation for wxComboPopup class
+// Purpose: interface of wxComboPopup
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxComboCtrl
+ @see wxComboCtrl
*/
class wxComboPopup
{
};
+
/**
@class wxComboCtrl
@wxheader{combo.h}
@category{ctrl}
@appearance{comboctrl.png}
- @seealso
- wxComboBox, wxChoice, wxOwnerDrawnComboBox, wxComboPopup, wxCommandEvent
+ @see wxComboBox, wxChoice, wxOwnerDrawnComboBox, wxComboPopup, wxCommandEvent
*/
class wxComboCtrl : public wxControl
{
*/
void UseAltPopupWindow(bool enable = true);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: combobox.h
-// Purpose: documentation for wxComboBox class
+// Purpose: interface of wxComboBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{combobox.png}
- @seealso
- wxListBox, wxTextCtrl, wxChoice, wxCommandEvent
+ @see wxListBox, wxTextCtrl, wxChoice, wxCommandEvent
*/
class wxComboBox : public wxControlWithItems
{
*/
void Undo();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: config.h
-// Purpose: documentation for wxConfigBase class
+// Purpose: interface of wxConfigBase
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
flag, which changes the default local configuration file to
~/.appname/appname
should be used. Notice that this flag is ignored if localFilename is
- provided. This function is new since wxWidgets version 2.8.2
+ provided.
+ @wxsince{2.8.2}
For wxFileConfig, you can also add wxCONFIG_USE_NO_ESCAPE_CHARACTERS which
will turn off character escaping for the values of entries stored in the
config
Currently, supported types of data are:
wxString, @e long, @e double, @e bool,
wxColour and any other types,
- for which functions wxToString
- and wxFromString are defined.
+ for which functions wxToString()
+ and wxFromString() are defined.
Try not to read long values into string variables and vice versa: although it
just might work with wxFileConfig, you will get a system error with
wxRegConfig because in the Windows registry the different types of entries are
//@{
/**
Reads a value of type T, for which function
- wxFromString is defined,
+ wxFromString() is defined,
returning @true if the value was found.
If the value was not found, @a defaultVal is used instead.
bool Read(const wxStringkey, T* value) const;
/**
Reads a value of type T, for which function
- wxFromString is defined, from the key and returns it.
+ wxFromString() is defined, from the key and returns it.
@a defaultVal is returned if the key is not found.
*/
T ReadObject(const wxString& key, T const& defaultVal) const;
//@{
/**
These functions write the specified value to the config file and return @true
- on success. In the last one, function wxToString must be
+ on success. In the last one, function wxToString() must be
defined for type @e T.
bool Write(const wxString& key, const T& buf);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: control.h
-// Purpose: documentation for wxControl class
+// Purpose: interface of wxControl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{control.png}
- @seealso
- wxValidator
+ @see wxValidator
*/
class wxControl : public wxWindow
{
*/
void SetLabel(const wxString& label);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: convauto.h
-// Purpose: documentation for wxConvAuto class
+// Purpose: interface of wxConvAuto
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_mbconvclasses "wxMBConv classes overview"
+ @see @ref overview_mbconvclasses "wxMBConv classes overview"
*/
class wxConvAuto : public wxMBConv
{
*/
static void SetFallbackEncoding(wxFontEncoding enc);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: cpp.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
literal or a macro (hence the advantage of using this macro instead of the
standard preprocessor @c # operator which doesn't work with macros).
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()
*/
#define wxSTRINGIZE(x) /* implementation is private */
/**
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
- equivalent of wxSTRINGIZE.
+ equivalent of wxSTRINGIZE().
*/
#define wxSTRINGIZE_T(x) /* implementation is private */
/////////////////////////////////////////////////////////////////////////////
// Name: cshelp.h
-// Purpose: documentation for wxHelpProvider class
+// Purpose: interface of wxHelpProvider
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{help}
- @seealso
- wxContextHelp, wxContextHelpButton, wxSimpleHelpProvider,
+ @see wxContextHelp, wxContextHelpButton, wxSimpleHelpProvider,
wxHelpControllerHelpProvider, wxWindow::SetHelpText, wxWindow::GetHelpTextAtPoint
*/
class wxHelpProvider
};
+
/**
@class wxHelpControllerHelpProvider
@wxheader{cshelp.h}
@library{wxcore}
@category{help}
- @seealso
- wxHelpProvider, wxSimpleHelpProvider, wxContextHelp, wxWindow::SetHelpText,
- wxWindow::GetHelpTextAtPoint
+ @see wxHelpProvider, wxSimpleHelpProvider, wxContextHelp,
+ wxWindow::SetHelpText, wxWindow::GetHelpTextAtPoint
*/
class wxHelpControllerHelpProvider : public wxSimpleHelpProvider
{
};
+
/**
@class wxContextHelp
@wxheader{cshelp.h}
@library{wxcore}
@category{help}
- @seealso
- wxHelpEvent, wxHelpController, wxContextHelpButton
+ @see wxHelpEvent, wxHelpController, wxContextHelpButton
*/
class wxContextHelp : public wxObject
{
};
+
/**
@class wxContextHelpButton
@wxheader{cshelp.h}
@library{wxcore}
@category{help}
- @seealso
- wxBitmapButton, wxContextHelp
+ @see wxBitmapButton, wxContextHelp
*/
class wxContextHelpButton : public wxBitmapButton
{
};
+
/**
@class wxSimpleHelpProvider
@wxheader{cshelp.h}
@library{wxcore}
@category{help}
- @seealso
- wxHelpProvider, wxHelpControllerHelpProvider, wxContextHelp,
+ @see wxHelpProvider, wxHelpControllerHelpProvider, wxContextHelp,
wxWindow::SetHelpText, wxWindow::GetHelpTextAtPoint
*/
class wxSimpleHelpProvider : public wxHelpProvider
public:
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: ctrlsub.h
-// Purpose: documentation for wxControlWithItems class
+// Purpose: interface of wxControlWithItems
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxControlWithItems::Clear
+ @see wxControlWithItems::Clear
*/
class wxControlWithItems : public wxControl
{
*/
bool SetStringSelection(const wxString& string);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: cursor.h
-// Purpose: documentation for wxCursor class
+// Purpose: interface of wxCursor
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{gdi}
@stdobjects
- Objects:
- wxNullCursor
- Pointers:
- wxSTANDARD_CURSOR
+ ::Objects:, ::wxNullCursor, ::Pointers:, ::wxSTANDARD_CURSOR,
+ ::wxHOURGLASS_CURSOR, ::wxCROSS_CURSOR,
- wxHOURGLASS_CURSOR
-
- wxCROSS_CURSOR
-
- @seealso
- wxBitmap, wxIcon, wxWindow::SetCursor, ::wxSetCursor
+ @see wxBitmap, wxIcon, wxWindow::SetCursor, ::wxSetCursor
*/
class wxCursor : public wxBitmap
{
*/
wxCursor operator =(const wxCursor& cursor);
};
+
+
+/**
+ FIXME
+*/
+wxCursor Objects:
+;
+
+/**
+ FIXME
+*/
+wxCursor wxNullCursor;
+
+/**
+ FIXME
+*/
+wxCursor Pointers:
+;
+
+/**
+ FIXME
+*/
+wxCursor wxSTANDARD_CURSOR;
+
+/**
+ FIXME
+*/
+wxCursor wxHOURGLASS_CURSOR;
+
+/**
+ FIXME
+*/
+wxCursor wxCROSS_CURSOR;
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: dataobj.h
-// Purpose: documentation for wxCustomDataObject class
+// Purpose: interface of wxCustomDataObject
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dnd}
- @seealso
- wxDataObject
+ @see wxDataObject
*/
class wxCustomDataObject : public wxDataObjectSimple
{
};
+
/**
@class wxDataObjectComposite
@wxheader{dataobj.h}
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_wxdndoverview "Clipboard and drag and drop overview",
+ @see @ref overview_wxdndoverview "Clipboard and drag and drop overview",
wxDataObject, wxDataObjectSimple, wxFileDataObject, wxTextDataObject, wxBitmapDataObject
*/
class wxDataObjectComposite : public wxDataObject
};
+
/**
@class wxDataObjectSimple
@wxheader{dataobj.h}
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_wxdndoverview "Clipboard and drag and drop overview", @ref
+ @see @ref overview_wxdndoverview "Clipboard and drag and drop overview", @ref
overview_samplednd "DnD sample", wxFileDataObject, wxTextDataObject, wxBitmapDataObject
*/
class wxDataObjectSimple : public wxDataObject
};
+
/**
@class wxBitmapDataObject
@wxheader{dataobj.h}
@library{wxcore}
@category{dnd}
- @seealso
- @ref overview_wxdndoverview "Clipboard and drag and drop overview",
+ @see @ref overview_wxdndoverview "Clipboard and drag and drop overview",
wxDataObject, wxDataObjectSimple, wxFileDataObject, wxTextDataObject, wxDataObject
*/
class wxBitmapDataObject : public wxDataObjectSimple
};
+
/**
@class wxDataFormat
@wxheader{dataobj.h}
@library{wxbase}
@category{dnd}
- @seealso
- @ref overview_wxdndoverview "Clipboard and drag and drop overview", @ref
+ @see @ref overview_wxdndoverview "Clipboard and drag and drop overview", @ref
overview_samplednd "DnD sample", wxDataObject
*/
class wxDataFormat
};
+
/**
@class wxURLDataObject
@wxheader{dataobj.h}
@library{wxcore}
@category{dnd}
- @seealso
- @ref overview_wxdndoverview "Clipboard and drag and drop overview", wxDataObject
+ @see @ref overview_wxdndoverview "Clipboard and drag and drop overview",
+ wxDataObject
*/
class wxURLDataObject
{
};
+
/**
@class wxDataObject
@wxheader{dataobj.h}
translation under Windows is not yet finished.
@b wxPython note: At this time this class is not directly usable from wxPython.
- Derive a class from wxPyDataObjectSimple
+ Derive a class from wxPyDataObjectSimple()
instead.
@b wxPerl note: This class is not currently usable from wxPerl; you may
@library{wxcore}
@category{dnd}
- @seealso
- @ref overview_wxdndoverview "Clipboard and drag and drop overview", @ref
+ @see @ref overview_wxdndoverview "Clipboard and drag and drop overview", @ref
overview_samplednd "DnD sample", wxFileDataObject, wxTextDataObject, wxBitmapDataObject, wxCustomDataObject, wxDropTarget, wxDropSource, wxTextDropTarget, wxFileDropTarget
*/
class wxDataObject
};
+
/**
@class wxTextDataObject
@wxheader{dataobj.h}
@library{wxcore}
@category{dnd}
- @seealso
- @ref overview_wxdndoverview "Clipboard and drag and drop overview",
+ @see @ref overview_wxdndoverview "Clipboard and drag and drop overview",
wxDataObject, wxDataObjectSimple, wxFileDataObject, wxBitmapDataObject
*/
class wxTextDataObject : public wxDataObjectSimple
};
+
/**
@class wxFileDataObject
@wxheader{dataobj.h}
@library{wxcore}
@category{dnd}
- @seealso
- wxDataObject, wxDataObjectSimple, wxTextDataObject, wxBitmapDataObject,
+ @see wxDataObject, wxDataObjectSimple, wxTextDataObject, wxBitmapDataObject,
wxDataObject
*/
class wxFileDataObject : public wxDataObjectSimple
virtual void AddFile(const wxString& file);
/**
- Returns the array of file names.
+ Returns the array() of file names.
*/
const wxArrayString GetFilenames() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dataview.h
-// Purpose: documentation for wxDataViewIconText class
+// Purpose: interface of wxDataViewIconText
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxDataViewEvent
@wxheader{dataview.h}
};
+
/**
@class wxDataViewIconTextRenderer
@wxheader{dataview.h}
};
+
/**
@class wxDataViewIndexListModel
@wxheader{dataview.h}
/**
Oberride this to indicate that the row has special font attributes.
This only affects the
- wxDataViewTextRendererText renderer.
+ wxDataViewTextRendererText() renderer.
See also wxDataViewItemAttr.
*/
bool GetAttr(unsigned int row, unsigned int col,
};
+
/**
@class wxDataViewModel
@wxheader{dataview.h}
/**
Oberride this to indicate that the item has special font attributes.
This only affects the
- wxDataViewTextRendererText renderer.
+ wxDataViewTextRendererText() renderer.
See also wxDataViewItemAttr.
*/
bool GetAttr(const wxDataViewItem& item, unsigned int col,
};
+
/**
@class wxDataViewCustomRenderer
@wxheader{dataview.h}
};
+
/**
@class wxDataViewBitmapRenderer
@wxheader{dataview.h}
};
+
/**
@class wxDataViewItemAttr
@wxheader{dataview.h}
This class is used to indicate to a wxDataViewCtrl
- that a certain Item has extra font attributes
+ that a certain Item() has extra font attributes
for its renderer. For this, it is required to override
wxDataViewModel::GetAttr.
Attributes are currently only supported by
- wxDataViewTextRendererText.
+ wxDataViewTextRendererText().
@library{wxadv}
@category{FIXME}
};
+
/**
@class wxDataViewItem
@wxheader{dataview.h}
};
+
/**
@class wxDataViewCtrl
@wxheader{dataview.h}
};
+
/**
@class wxDataViewModelNotifier
@wxheader{dataview.h}
};
+
/**
@class wxDataViewRenderer
@wxheader{dataview.h}
};
+
/**
@class wxDataViewTextRenderer
@wxheader{dataview.h}
};
+
/**
@class wxDataViewProgressRenderer
@wxheader{dataview.h}
};
+
/**
@class wxDataViewSpinRenderer
@wxheader{dataview.h}
};
+
/**
@class wxDataViewToggleRenderer
@wxheader{dataview.h}
};
+
/**
@class wxDataViewTreeCtrl
@wxheader{dataview.h}
};
+
/**
@class wxDataViewTreeStore
@wxheader{dataview.h}
};
+
/**
@class wxDataViewDateRenderer
@wxheader{dataview.h}
};
+
/**
@class wxDataViewTextRendererAttr
@wxheader{dataview.h}
};
+
/**
@class wxDataViewColumn
@wxheader{dataview.h}
*/
void SetTitle(const wxString& title);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: datectrl.h
-// Purpose: documentation for wxDatePickerCtrl class
+// Purpose: interface of wxDatePickerCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{miscpickers}
@appearance{datepickerctrl.png}
- @seealso
- wxCalendarCtrl, wxDateEvent
+ @see wxCalendarCtrl, wxDateEvent
*/
class wxDatePickerCtrl : public wxControl
{
*/
void SetValue(const wxDateTime& dt);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dateevt.h
-// Purpose: documentation for wxDateEvent class
+// Purpose: interface of wxDateEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
void SetDate(const wxDateTime& date);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: datetime.h
-// Purpose: documentation for wxDateTime class
+// Purpose: interface of wxDateTime
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{data}
- @seealso
- @ref overview_wxdatetimeoverview "Date classes overview", wxTimeSpan,
+ @see @ref overview_wxdatetimeoverview "Date classes overview", wxTimeSpan,
wxDateSpan, wxCalendarCtrl
*/
class wxDateTime
static int ConvertYearToBC(int year);
/**
- These functions carry out arithmetics on the wxDateTime
+ These functions carry out arithmetics() on the wxDateTime
objects. As explained in the overview, either wxTimeSpan or wxDateSpan may be
added to wxDateTime, hence all functions are overloaded to accept both
arguments.
/**
Returns the object having the same date component as this one but time of
00:00:00.
- This function is new since wxWidgets version 2.8.2
+
+ @wxsince{2.8.2}
@see ResetTime()
*/
};
+
/**
@class wxDateTimeWorkDays
@wxheader{datetime.h}
};
+
/**
@class wxDateSpan
@wxheader{datetime.h}
@library{wxbase}
@category{data}
- @seealso
- @ref overview_wxdatetimeoverview "Date classes overview", wxDateTime
+ @see @ref overview_wxdatetimeoverview "Date classes overview", wxDateTime
*/
class wxDateSpan
{
};
+
/**
@class wxTimeSpan
@wxheader{datetime.h}
@library{wxbase}
@category{data}
- @seealso
- @ref overview_wxdatetimeoverview "Date classes overview", wxDateTime
+ @see @ref overview_wxdatetimeoverview "Date classes overview", wxDateTime
*/
class wxTimeSpan
{
};
+
/**
@class wxDateTimeHolidayAuthority
@wxheader{datetime.h}
public:
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: datstrm.h
-// Purpose: documentation for wxDataOutputStream class
+// Purpose: interface of wxDataOutputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxDataInputStream
@wxheader{datstrm.h}
*/
wxString ReadString();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dc.h
-// Purpose: documentation for wxDC class
+// Purpose: interface of wxDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dc}
- @seealso
- Overview
+ @see Overview()
*/
class wxDC : public wxObject
{
/**
Returns the depth (number of bits/pixel) of this DC.
- @see wxDisplayDepth
+ @see wxDisplayDepth()
*/
int GetDepth() const;
};
+
/**
@class wxDCClipper
@wxheader{dc.h}
@library{wxcore}
@category{gdi}
- @seealso
- wxDC::SetClippingRegion
+ @see wxDC::SetClippingRegion
*/
class wxDCClipper
{
wxDCClipper(wxDC& dc, int x, int y, int w, int h);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dcbuffer.h
-// Purpose: documentation for wxBufferedDC class
+// Purpose: interface of wxBufferedDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dc}
- @seealso
- wxDC, wxMemoryDC, wxBufferedPaintDC, wxAutoBufferedPaintDC
+ @see wxDC, wxMemoryDC, wxBufferedPaintDC, wxAutoBufferedPaintDC
*/
class wxBufferedDC : public wxMemoryDC
{
};
+
/**
@class wxAutoBufferedPaintDC
@wxheader{dcbuffer.h}
@library{wxbase}
@category{dc}
- @seealso
- wxDC, wxBufferedPaintDC
+ @see wxDC, wxBufferedPaintDC
*/
class wxAutoBufferedPaintDC : public wxBufferedPaintDC
{
};
+
/**
@class wxBufferedPaintDC
@wxheader{dcbuffer.h}
@library{wxcore}
@category{dc}
- @seealso
- wxDC, wxBufferedDC, wxAutoBufferedPaintDC
+ @see wxDC, wxBufferedDC, wxAutoBufferedPaintDC
*/
class wxBufferedPaintDC : public wxBufferedDC
{
object, using a wxPaintDC.
*/
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dcclient.h
-// Purpose: documentation for wxPaintDC class
+// Purpose: interface of wxPaintDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dc}
- @seealso
- wxDC, wxMemoryDC, wxPaintDC, wxWindowDC, wxScreenDC
+ @see wxDC, wxMemoryDC, wxPaintDC, wxWindowDC, wxScreenDC
*/
class wxPaintDC : public wxWindowDC
{
};
+
/**
@class wxClientDC
@wxheader{dcclient.h}
@library{wxcore}
@category{dc}
- @seealso
- wxDC, wxMemoryDC, wxPaintDC, wxWindowDC, wxScreenDC
+ @see wxDC, wxMemoryDC, wxPaintDC, wxWindowDC, wxScreenDC
*/
class wxClientDC : public wxWindowDC
{
};
+
/**
@class wxWindowDC
@wxheader{dcclient.h}
@library{wxcore}
@category{dc}
- @seealso
- wxDC, wxMemoryDC, wxPaintDC, wxClientDC, wxScreenDC
+ @see wxDC, wxMemoryDC, wxPaintDC, wxClientDC, wxScreenDC
*/
class wxWindowDC : public wxDC
{
*/
wxWindowDC(wxWindow* window);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dcmemory.h
-// Purpose: documentation for wxMemoryDC class
+// Purpose: interface of wxMemoryDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dc}
- @seealso
- wxBitmap, wxDC
+ @see wxBitmap, wxDC
*/
class wxMemoryDC : public wxDC
{
*/
void SelectObjectAsSource(const wxBitmap& bitmap);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dcmirror.h
-// Purpose: documentation for wxMirrorDC class
+// Purpose: interface of wxMirrorDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
wxMirrorDC(wxDC& dc, bool mirror);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dcprint.h
-// Purpose: documentation for wxPrinterDC class
+// Purpose: interface of wxPrinterDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{printing}
- @seealso
- @ref overview_printingoverview "Printing framework overview", wxDC
+ @see @ref overview_printingoverview "Printing framework overview", wxDC
*/
class wxPrinterDC : public wxDC
{
*/
wxRect wxPrinterDC::GetPaperRect();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dcps.h
-// Purpose: documentation for wxPostScriptDC class
+// Purpose: interface of wxPostScriptDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: dcscreen.h
-// Purpose: documentation for wxScreenDC class
+// Purpose: interface of wxScreenDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dc}
- @seealso
- wxDC, wxMemoryDC, wxPaintDC, wxClientDC, wxWindowDC
+ @see wxDC, wxMemoryDC, wxPaintDC, wxClientDC, wxWindowDC
*/
class wxScreenDC : public wxDC
{
bool StartDrawingOnTop(wxRect* rect = NULL);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dcsvg.h
-// Purpose: documentation for wxSVGFileDC class
+// Purpose: interface of wxSVGFileDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- @b Members
+ @see @b Members
*/
class wxSVGFileDC : public wxDC
{
*/
bool StartDoc(const wxString& message);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dde.h
-// Purpose: documentation for wxDDEConnection class
+// Purpose: interface of wxDDEConnection
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxDDEClient, wxDDEServer, @ref overview_ipcoverview "Interprocess
+ @see wxDDEClient, wxDDEServer, @ref overview_ipcoverview "Interprocess
communications overview"
*/
class wxDDEConnection : public wxObject
};
+
/**
@class wxDDEClient
@wxheader{dde.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxDDEServer, wxDDEConnection, @ref overview_ipcoverview "Interprocess
+ @see wxDDEServer, wxDDEConnection, @ref overview_ipcoverview "Interprocess
communications overview"
*/
class wxDDEClient : public wxObject
};
+
/**
@class wxDDEServer
@wxheader{dde.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxDDEClient, wxDDEConnection, @ref overview_ipcoverview "IPC overview"
+ @see wxDDEClient, wxDDEConnection, @ref overview_ipcoverview "IPC overview"
*/
class wxDDEServer
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
Called when wxWidgets exits, to clean up the DDE system. This no longer needs
to be
called by the application.
- See also wxDDEInitialize.
+ See also wxDDEInitialize().
*/
void wxDDECleanUp();
This no longer needs to be called by the application: it will be called
by wxWidgets if necessary.
See also wxDDEServer, wxDDEClient, wxDDEConnection,
- wxDDECleanUp.
+ wxDDECleanUp().
*/
void wxDDEInitialize();
/////////////////////////////////////////////////////////////////////////////
// Name: debug.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/**
Will always generate an assert error if this code is reached (in debug mode).
-See also: wxFAIL_MSG
+See also: wxFAIL_MSG()
*/
wxFAIL();
/**
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
-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
a dialog asking whether he wants to abort the program, continue or continue
ignoring any subsequent assert failures, you may override
it may be used in the "default:" branch of a switch statement if all possible
cases are processed above.
- @see wxFAIL
+ @see wxFAIL()
*/
#define wxFAIL_MSG(msg) /* implementation is private */
Assert macro with message. An error message will be generated if the condition
is @false.
- @see wxASSERT, wxCOMPILE_TIME_ASSERT
+ @see wxASSERT(), wxCOMPILE_TIME_ASSERT()
*/
#define wxASSERT_MSG(condition, msg) /* implementation is private */
/**
- This is the same as wxCHECK2, but
- wxFAIL_MSG with the specified @a msg is called
+ This is the same as wxCHECK2(), but
+ wxFAIL_MSG() with the specified @a msg is called
instead of wxFAIL() if the @a condition is @false.
*/
#define wxCHECK2(condition, operation, msg) /* implementation is private */
Please note that the condition in wxASSERT() should have no side effects
because it will not be executed in release mode at all.
- @see wxASSERT_MSG, wxCOMPILE_TIME_ASSERT
+ @see wxASSERT_MSG(), wxCOMPILE_TIME_ASSERT()
*/
#define wxASSERT(condition) /* implementation is private */
Checks that the condition is @true, and returns if not (FAILs with given error
message in debug mode). This check is done even in release mode.
This macro should be used in void functions instead of
- wxCHECK_MSG.
+ wxCHECK_MSG().
*/
#define wxCHECK_RET(condition, msg) /* implementation is private */
/**
- Checks that the condition is @true and wxFAIL and execute
+ Checks that the condition is @true and wxFAIL() and execute
@a operation if it is not. This is a generalisation of
- wxCHECK and may be used when something else than just
+ wxCHECK() and may be used when something else than just
returning from the function must be done when the @a condition is @false.
This check is done even in release mode.
*/
#define wxCHECK2(condition, operation) /* implementation is private */
/**
- This macro is identical to wxCOMPILE_TIME_ASSERT2
+ This macro is identical to wxCOMPILE_TIME_ASSERT2()
except that it allows you to specify a unique @a name for the struct
internally defined by this macro to avoid getting the compilation errors
- described above.
+ described above().
*/
#define wxCOMPILE_TIME_ASSERT(condition, msg, name) /* implementation is private */
(FAILs in debug mode).
This check is done even in release mode.
This macro may be only used in non-void functions, see also
- wxCHECK_RET.
+ wxCHECK_RET().
*/
#define wxCHECK_MSG(condition, retValue, msg) /* implementation is private */
unique by using the @c __LINE__ in it but it may still not work if you
use it on the same line in two different source files. In this case you may
either change the line in which either of them appears on or use the
- wxCOMPILE_TIME_ASSERT2 macro.
+ wxCOMPILE_TIME_ASSERT2() macro.
Also note that Microsoft Visual C++ has a bug which results in compiler errors
if you use this macro with 'Program Database For Edit And Continue'
(@c /ZI) option, so you shouldn't use it ('Program Database'
(@c /Zi) is ok though) for the code making use of this macro.
- @see wxASSERT_MSG, wxASSERT_MIN_BITSIZE
+ @see wxASSERT_MSG(), wxASSERT_MIN_BITSIZE()
*/
#define wxCOMPILE_TIME_ASSERT(condition, msg) /* implementation is private */
/////////////////////////////////////////////////////////////////////////////
// Name: debugrpt.h
-// Purpose: documentation for wxDebugReportPreview class
+// Purpose: interface of wxDebugReportPreview
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxDebugReportCompress
@wxheader{debugrpt.h}
};
+
/**
@class wxDebugReport
@wxheader{debugrpt.h}
wxDebugReport is used to generate a debug report, containing information about
the program current state. It is usually used from
wxApp::OnFatalException as shown in the
- sample.
+ sample().
A wxDebugReport object contains one or more files. A few of them can be created
by the
};
+
/**
@class wxDebugReportPreviewStd
@wxheader{debugrpt.h}
};
+
/**
@class wxDebugReportUpload
@wxheader{debugrpt.h}
*/
bool OnServerReply();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: defs.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
//@}
/**
- This macro is similar to wxDEPRECATED but can be used
+ This macro is similar to wxDEPRECATED() but can be used
to not only declare the function @a func as deprecated but to also provide
its (inline) implementation @e body.
It can be used as following:
void wxVaCopy(va_list argptrDst, va_list argptrSrc);
/**
- This is a special version of wxDEPRECATED macro which
+ 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 --
/////////////////////////////////////////////////////////////////////////////
// Name: dialog.h
-// Purpose: documentation for wxDialog class
+// Purpose: interface of wxDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{cmndlg}
- @seealso
- @ref overview_wxdialogoverview, wxFrame, @ref overview_validatoroverview
+ @see @ref overview_wxdialogoverview, wxFrame, @ref overview_validatoroverview
"Validator overview"
*/
class wxDialog : public wxTopLevelWindow
};
+
/**
@class wxDialogLayoutAdapter
@wxheader{dialog.h}
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_autoscrollingdialogs "Automatic scrolling dialogs"
+ @see @ref overview_autoscrollingdialogs "Automatic scrolling dialogs"
*/
class wxDialogLayoutAdapter
{
*/
bool DoLayoutAdaptation(wxDialog* dialog);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dialup.h
-// Purpose: documentation for wxDialUpManager class
+// Purpose: interface of wxDialUpManager
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{net}
- @seealso
- @ref overview_sampledialup "dialup sample", wxDialUpEvent
+ @see @ref overview_sampledialup "dialup sample", wxDialUpEvent
*/
class wxDialUpManager
{
};
+
/**
@class wxDialUpEvent
@wxheader{dialup.h}
*/
bool IsOwnEvent() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dir.h
-// Purpose: documentation for wxDirTraverser class
+// Purpose: interface of wxDirTraverser
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxDir
@wxheader{dir.h}
big, it could be
far from real size of the directory.
See also: wxFileName::GetHumanReadableSize,
- wxGetDiskSpace
+ wxGetDiskSpace()
*/
static wxULongLong GetTotalSize(const wxString& dir,
wxArrayString* filesSkipped = NULL);
const wxString& filespec = wxEmptyString,
int flags = wxDIR_DEFAULT);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dirctrl.h
-// Purpose: documentation for wxGenericDirCtrl class
+// Purpose: interface of wxGenericDirCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
void ShowHidden(bool show);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dirdlg.h
-// Purpose: documentation for wxDirDialog class
+// Purpose: interface of wxDirDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{cmndlg}
- @seealso
- @ref overview_wxdirdialogoverview "wxDirDialog overview", wxFileDialog
+ @see @ref overview_wxdirdialogoverview "wxDirDialog overview", wxFileDialog
*/
class wxDirDialog : public wxDialog
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: display.h
-// Purpose: documentation for wxDisplay class
+// Purpose: interface of wxDisplay
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxClientDisplayRect, wxDisplaySize, wxDisplaySizeMM
+ @see wxClientDisplayRect(), wxDisplaySize(), wxDisplaySizeMM()
*/
class wxDisplay
{
*/
bool IsPrimary();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dnd.h
-// Purpose: documentation for wxTextDropTarget class
+// Purpose: interface of wxTextDropTarget
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dnd}
- @seealso
- @ref overview_wxdndoverview, wxDropSource, wxDropTarget, wxFileDropTarget
+ @see @ref overview_wxdndoverview, wxDropSource, wxDropTarget, wxFileDropTarget
*/
class wxTextDropTarget : public wxDropTarget
{
};
+
/**
@class wxDropTarget
@wxheader{dnd.h}
@library{wxcore}
@category{dnd}
- @seealso
- wxDropSource, wxTextDropTarget, wxFileDropTarget, wxDataFormat, wxDataObject
+ @see wxDropSource, wxTextDropTarget, wxFileDropTarget, wxDataFormat,
+ wxDataObject
*/
class wxDropTarget
{
};
+
/**
@class wxDropSource
@wxheader{dnd.h}
@library{wxcore}
@category{dnd}
- @seealso
- wxDropTarget, wxTextDropTarget, wxFileDropTarget
+ @see wxDropTarget, wxTextDropTarget, wxFileDropTarget
*/
class wxDropSource
{
SetData() later.
Note that the exact type of @a iconCopy and subsequent parameters differs
between wxMSW and wxGTK: these are cursors under Windows but icons for GTK.
- You should use the macro wxDROP_ICON in portable
+ You should use the macro wxDROP_ICON() in portable
programs instead of directly using either of these types.
@param win
};
+
/**
@class wxFileDropTarget
@wxheader{dnd.h}
@library{wxcore}
@category{dnd}
- @seealso
- @ref overview_wxdndoverview, wxDropSource, wxDropTarget, wxTextDropTarget
+ @see @ref overview_wxdndoverview, wxDropSource, wxDropTarget, wxTextDropTarget
*/
class wxFileDropTarget : public wxDropTarget
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: docmdi.h
-// Purpose: documentation for wxDocMDIParentFrame class
+// Purpose: interface of wxDocMDIParentFrame
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
MDI parent frames.
It cooperates with the wxView, wxDocument,
- wxDocManager and wxDocTemplates classes.
+ wxDocManager and wxDocTemplates() classes.
See the example application in @c samples/docview.
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_docviewoverview, wxMDIParentFrame
+ @see @ref overview_docviewoverview, wxMDIParentFrame
*/
class wxDocMDIParentFrame : public wxMDIParentFrame
{
};
+
/**
@class wxDocMDIChildFrame
@wxheader{docmdi.h}
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_docviewoverview, wxMDIChildFrame
+ @see @ref overview_docviewoverview, wxMDIChildFrame
*/
class wxDocMDIChildFrame : public wxMDIChildFrame
{
The view associated with the frame.
*/
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: docview.h
-// Purpose: documentation for wxDocTemplate class
+// Purpose: interface of wxDocTemplate
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dvf}
- @seealso
- @ref overview_wxdoctemplateoverview "wxDocTemplate overview", wxDocument, wxView
+ @see @ref overview_wxdoctemplateoverview "wxDocTemplate overview", wxDocument,
+ wxView
*/
class wxDocTemplate : public wxObject
{
};
+
/**
@class wxDocManager
@wxheader{docview.h}
@library{wxcore}
@category{dvf}
- @seealso
- @ref overview_wxdocmanageroverview "wxDocManager overview", wxDocument, wxView,
- wxDocTemplate, wxFileHistory
+ @see @ref overview_wxdocmanageroverview "wxDocManager overview", wxDocument,
+ wxView, wxDocTemplate, wxFileHistory
*/
class wxDocManager : public wxEvtHandler
{
/**
Loads the file history from a config object.
- @see wxConfig
+ @see wxConfig()
*/
void FileHistoryLoad(wxConfigBase& config);
Saves the file history into a config object. This must be called
explicitly by the application.
- @see wxConfig
+ @see wxConfig()
*/
void FileHistorySave(wxConfigBase& resourceFile);
};
+
/**
@class wxView
@wxheader{docview.h}
@library{wxcore}
@category{dvf}
- @seealso
- @ref overview_wxviewoverview "wxView overview", wxDocument, wxDocTemplate,
+ @see @ref overview_wxviewoverview "wxView overview", wxDocument, wxDocTemplate,
wxDocManager
*/
class wxView : public wxEvtHandler
};
+
/**
@class wxDocChildFrame
@wxheader{docview.h}
@library{wxcore}
@category{dvf}
- @seealso
- @ref overview_docviewoverview, wxFrame
+ @see @ref overview_docviewoverview, wxFrame
*/
class wxDocChildFrame : public wxFrame
{
};
+
/**
@class wxDocParentFrame
@wxheader{docview.h}
SDI (not MDI) parent frames.
It cooperates with the wxView, wxDocument,
- wxDocManager and wxDocTemplates classes.
+ wxDocManager and wxDocTemplates() classes.
See the example application in @c samples/docview.
@library{wxcore}
@category{dvf}
- @seealso
- @ref overview_docviewoverview, wxFrame
+ @see @ref overview_docviewoverview, wxFrame
*/
class wxDocParentFrame : public wxFrame
{
};
+
/**
@class wxDocument
@wxheader{docview.h}
@library{wxcore}
@category{dvf}
- @seealso
- @ref overview_wxdocumentoverview "wxDocument overview", wxView, wxDocTemplate,
- wxDocManager
+ @see @ref overview_wxdocumentoverview "wxDocument overview", wxView,
+ wxDocTemplate, wxDocManager
*/
class wxDocument : public wxEvtHandler
{
/**
Gets the document type name for this document. See the comment for
- documentTypeName.
+ documentTypeName().
*/
wxString GetDocumentName() const;
/**
Sets the document type name for this document. See the comment for
- documentTypeName.
+ documentTypeName().
*/
void SetDocumentName(const wxString& name);
};
+
/**
@class wxFileHistory
@wxheader{docview.h}
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_wxfilehistoryoverview "wxFileHistory overview", wxDocManager
+ @see @ref overview_wxfilehistoryoverview "wxFileHistory overview", wxDocManager
*/
class wxFileHistory : public wxObject
{
Loads the file history from the given config object. This function should be
called explicitly by the application.
- @see wxConfig
+ @see wxConfig()
*/
void Load(wxConfigBase& config);
Saves the file history into the given config object. This must be called
explicitly by the application.
- @see wxConfig
+ @see wxConfig()
*/
void Save(wxConfigBase& config);
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: dragimag.h
-// Purpose: documentation for wxDragImage class
+// Purpose: interface of wxDragImage
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
const wxRect& sourceRect,
const wxRect& destRect) const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dynarray.h
-// Purpose: documentation for wxArray<T> class
+// Purpose: interface of wxArray<T>
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxcontaineroverview, wxListT, wxVectorT
+ @see @ref overview_wxcontaineroverview, wxListT(), wxVectorT()
*/
class wxArray<T>
{
because the other array types never take ownership of their elements. Also note
that you cannot append more than one pointer as reusing it would lead to
deleting it twice (or more) and hence to a crash.
- You may also use WX_APPEND_ARRAY macro to append all
+ You may also use WX_APPEND_ARRAY() macro to append all
elements of one array to another one but it is more efficient to use
@a copies parameter and modify the elements in place later if you plan to
append a lot of items.
wxArray::SetCount
- WX_APPEND_ARRAY
+ WX_APPEND_ARRAY()
- WX_PREPEND_ARRAY
+ WX_PREPEND_ARRAY()
*/
least) forward declared for WX_DEFINE_ARRAY, WX_DEFINE_SORTED_ARRAY and
WX_DECLARE_OBJARRAY macros and must be fully declared before you use
WX_DEFINE_OBJARRAY macro.
- WX_DEFINE_ARRAY
+ WX_DEFINE_ARRAY()
- WX_DEFINE_EXPORTED_ARRAY
+ WX_DEFINE_EXPORTED_ARRAY()
- WX_DEFINE_USER_EXPORTED_ARRAY
+ WX_DEFINE_USER_EXPORTED_ARRAY()
- WX_DEFINE_SORTED_ARRAY
+ WX_DEFINE_SORTED_ARRAY()
- WX_DEFINE_SORTED_EXPORTED_ARRAY
+ WX_DEFINE_SORTED_EXPORTED_ARRAY()
- WX_DEFINE_SORTED_USER_EXPORTED_ARRAY
+ WX_DEFINE_SORTED_USER_EXPORTED_ARRAY()
- WX_DECLARE_EXPORTED_OBJARRAY
+ WX_DECLARE_EXPORTED_OBJARRAY()
- WX_DECLARE_USER_EXPORTED_OBJARRAY
+ WX_DECLARE_USER_EXPORTED_OBJARRAY()
- WX_DEFINE_OBJARRAY
+ WX_DEFINE_OBJARRAY()
- WX_DEFINE_EXPORTED_OBJARRAY
+ WX_DEFINE_EXPORTED_OBJARRAY()
- WX_DEFINE_USER_EXPORTED_OBJARRAY
+ WX_DEFINE_USER_EXPORTED_OBJARRAY()
To slightly complicate the matters even further, the operator - defined by
default for the array iterators by these macros only makes sense if the array
element type is not a pointer itself and, although it still works, this
To create an array of a simple type, simply append the type you want in CAPS to
the array definition.
For example, for an integer array, you'd use one of the following variants:
- WX_DEFINE_ARRAY_INT
+ WX_DEFINE_ARRAY_INT()
- WX_DEFINE_EXPORTED_ARRAY_INT
+ WX_DEFINE_EXPORTED_ARRAY_INT()
- WX_DEFINE_USER_EXPORTED_ARRAY_INT
+ WX_DEFINE_USER_EXPORTED_ARRAY_INT()
- WX_DEFINE_SORTED_ARRAY_INT
+ WX_DEFINE_SORTED_ARRAY_INT()
- WX_DEFINE_SORTED_EXPORTED_ARRAY_INT
+ WX_DEFINE_SORTED_EXPORTED_ARRAY_INT()
- WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT
+ WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT()
*/
array equal to @a item is removed, an assert failure will result from an
attempt to remove an item which doesn't exist in the array.
When an element is removed from wxObjArray it is deleted by the array - use
- Detach if you don't want this to happen. On the
+ Detach() if you don't want this to happen. On the
other hand, when an object is removed from a wxArray nothing happens - you
should delete it manually if required:
- See also WX_CLEAR_ARRAY macro which deletes all
+ See also WX_CLEAR_ARRAY() macro which deletes all
elements of a wxArray (supposed to contain pointers).
*/
Remove(T item);
/**
Removes @a count elements starting at @a index from the array. When an
element is removed from wxObjArray it is deleted by the array - use
- Detach if you don't want this to happen. On
+ Detach() if you don't want this to happen. On
the other hand, when an object is removed from a wxArray nothing happens -
you should delete it manually if required:
- See also WX_CLEAR_ARRAY macro which deletes all
+ See also WX_CLEAR_ARRAY() macro which deletes all
elements of a wxArray (supposed to contain pointers).
*/
RemoveAt(size_t index, size_t count = 1);
/**
- WX_CLEAR_ARRAY
+ WX_CLEAR_ARRAY()
wxArray::Empty
needed for exporting an array from a user DLL.
Example:
- You must use WX_DEFINE_OBJARRAY macro to define
+ You must use WX_DEFINE_OBJARRAY() macro to define
the array class - otherwise you would get link errors.
*/
WX_DECLARE_OBJARRAY(T, name);
//@{
/**
This macro defines the methods of the array class @a name not defined by the
- WX_DECLARE_OBJARRAY macro. You must include the
+ WX_DECLARE_OBJARRAY() macro. You must include the
file wx/arrimpl.cpp before using this macro and you must have the full
declaration of the class of array elements in scope! If you forget to do the
first, the error will be caught by the compiler, but, unfortunately, many
/**
The wxObjArray destructor deletes all the items owned by the array. This is not
done by wxArray and wxSortedArray versions - you may use
- WX_CLEAR_ARRAY macro for this.
+ WX_CLEAR_ARRAY() macro for this.
*/
~wxArray();
~wxSortedArray();
~wxObjArray();
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: dynlib.h
-// Purpose: documentation for wxDynamicLibraryDetails class
+// Purpose: interface of wxDynamicLibraryDetails
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxDllLoader
@wxheader{dynlib.h}
};
+
/**
@class wxDynamicLibrary
@wxheader{dynlib.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxDynamicLibrary::CanonicalizePluginName
+ @see wxDynamicLibrary::CanonicalizePluginName
*/
class wxDynamicLibrary
{
Returns pointer to symbol @a name in the library or @NULL if the library
contains no such symbol.
- @see wxDYNLIB_FUNCTION
+ @see wxDYNLIB_FUNCTION()
*/
void* GetSymbol(const wxString& name) const;
Returns @true if the symbol with the given @a name is present in the dynamic
library, @false otherwise. Unlike GetSymbol(),
this function doesn't log an error message if the symbol is not found.
- This function is new since wxWidgets version 2.5.4
+
+ @wxsince{2.5.4}
*/
bool HasSymbol(const wxString& name) const;
bool IsLoaded() const;
/**
- This static method returns an array containing the details
+ This static method returns an array() containing the details
of all modules loaded into the address space of the current project, the array
elements are object of @c wxDynamicLibraryDetails class. The array will
be empty if an error occurred.
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: editlbox.h
-// Purpose: documentation for wxEditableListBox class
+// Purpose: interface of wxEditableListBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxadv}
@category{FIXME}
- @seealso
- wxListBox
+ @see wxListBox
*/
class wxEditableListBox : public wxPanel
{
*/
void SetStrings(const wxArrayString& strings);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: encconv.h
-// Purpose: documentation for wxEncodingConverter class
+// Purpose: interface of wxEncodingConverter
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{misc}
- @seealso
- wxFontMapper, wxMBConv, @ref overview_nonenglishoverview "Writing non-English
- applications"
+ @see wxFontMapper, wxMBConv, @ref overview_nonenglishoverview "Writing
+ non-English applications"
*/
class wxEncodingConverter : public wxObject
{
bool Init(wxFontEncoding input_enc, wxFontEncoding output_enc,
int method = wxCONVERT_STRICT);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: event.h
-// Purpose: documentation for wxKeyEvent class
+// Purpose: interface of wxKeyEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
1, the ASCII value of this key combination.
You may discover how the other keys on your system behave interactively by
- running the text wxWidgets sample and pressing some keys
+ running the text() wxWidgets sample and pressing some keys
in any of the text controls shown in it.
@b Note: If a key down (@c EVT_KEY_DOWN) event is caught and
/**
Returns the virtual key code. ASCII events return normal ASCII values,
while non-ASCII events return values such as @b WXK_LEFT for the
- left cursor key. See Keycodes for a full list of
+ left cursor key. See Keycodes() for a full list of
the virtual key codes.
Note that in Unicode build, the returned value is meaningful only if the
user entered a character that can be represented in current locale's default
long m_keyCode
@b Deprecated: Please use GetKeyCode()
instead!
- Virtual keycode. See Keycodes for a list of identifiers.
+ Virtual keycode. See Keycodes() for a list of identifiers.
*/
};
+
/**
@class wxJoystickEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxJoystick
+ @see wxJoystick
*/
class wxJoystickEvent : public wxEvent
{
};
+
/**
@class wxScrollWinEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxScrollEvent, @ref overview_eventhandlingoverview
+ @see wxScrollEvent, @ref overview_eventhandlingoverview
*/
class wxScrollWinEvent : public wxEvent
{
};
+
/**
@class wxSysColourChangedEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview
+ @see @ref overview_eventhandlingoverview
*/
class wxSysColourChangedEvent : public wxEvent
{
};
+
/**
@class wxWindowCreateEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview, wxWindowDestroyEvent
+ @see @ref overview_eventhandlingoverview, wxWindowDestroyEvent
*/
class wxWindowCreateEvent : public wxCommandEvent
{
};
+
/**
@class wxPaintEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview
+ @see @ref overview_eventhandlingoverview
*/
class wxPaintEvent : public wxEvent
{
};
+
/**
@class wxMaximizeEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview, wxTopLevelWindow::Maximize,
+ @see @ref overview_eventhandlingoverview, wxTopLevelWindow::Maximize,
wxTopLevelWindow::IsMaximized
*/
class wxMaximizeEvent : public wxEvent
};
+
/**
@class wxUpdateUIEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview
+ @see @ref overview_eventhandlingoverview
*/
class wxUpdateUIEvent : public wxCommandEvent
{
};
+
/**
@class wxClipboardTextEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxClipboard
+ @see wxClipboard
*/
class wxClipboardTextEvent : public wxCommandEvent
{
};
+
/**
@class wxMouseEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxKeyEvent::CmdDown
+ @see wxKeyEvent::CmdDown
*/
class wxMouseEvent : public wxEvent
{
Currently this function is implemented only in wxMac and returns -1 for the
other platforms (you can still distinguish simple clicks from double-clicks as
they generate different kinds of events however).
- This function is new since wxWidgets version 2.9.0
+
+ @wxsince{2.9.0}
*/
int GetClickCount() const;
};
+
/**
@class wxDropFilesEvent
@wxheader{event.h}
wxWindow::DragAcceptFiles.
Important note: this is a separate implementation to the more general
- drag and drop implementation documented here. It uses the
+ drag and drop implementation documented here(). It uses the
older, Windows message-based approach of dropping files.
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview
+ @see @ref overview_eventhandlingoverview
*/
class wxDropFilesEvent : public wxEvent
{
};
+
/**
@class wxCommandEvent
@wxheader{event.h}
};
+
/**
@class wxActivateEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview, wxApp::IsActive
+ @see @ref overview_eventhandlingoverview, wxApp::IsActive
*/
class wxActivateEvent : public wxEvent
{
};
+
/**
@class wxContextMenuEvent
@wxheader{event.h}
means that the event originated
from a keyboard context button event, and you should compute a suitable
position yourself,
- for example by calling wxGetMousePosition.
+ for example by calling wxGetMousePosition().
When a keyboard context menu button is pressed on Windows, a right-click event
with default position is sent first,
@library{wxcore}
@category{events}
- @seealso
- @ref overview_wxcommandevent "Command events", @ref
+ @see @ref overview_wxcommandevent "Command events", @ref
overview_eventhandlingoverview
*/
class wxContextMenuEvent : public wxCommandEvent
};
+
/**
@class wxEraseEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview
+ @see @ref overview_eventhandlingoverview
*/
class wxEraseEvent : public wxEvent
{
};
+
/**
@class wxFocusEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview
+ @see @ref overview_eventhandlingoverview
*/
class wxFocusEvent : public wxEvent
{
};
+
/**
@class wxChildFocusEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview
+ @see @ref overview_eventhandlingoverview
*/
class wxChildFocusEvent : public wxCommandEvent
{
};
+
/**
@class wxMouseCaptureLostEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxMouseCaptureChangedEvent, @ref overview_eventhandlingoverview,
+ @see wxMouseCaptureChangedEvent, @ref overview_eventhandlingoverview,
wxWindow::CaptureMouse, wxWindow::ReleaseMouse, wxWindow::GetCapture
*/
class wxMouseCaptureLostEvent : public wxEvent
};
+
/**
@class wxNotifyEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxNotebookEvent
+ @see wxNotebookEvent
*/
class wxNotifyEvent : public wxCommandEvent
{
};
+
/**
@class wxHelpEvent
@wxheader{event.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxContextHelp, wxDialog, @ref overview_eventhandlingoverview
+ @see wxContextHelp, wxDialog, @ref overview_eventhandlingoverview
*/
class wxHelpEvent : public wxCommandEvent
{
MS Windows.
The application may handle events generated using the keyboard or mouse
- differently, e.g. by using wxGetMousePosition
+ differently, e.g. by using wxGetMousePosition()
for the mouse events.
@see SetOrigin()
};
+
/**
@class wxScrollEvent
@wxheader{event.h}
A scroll event holds information about events sent from stand-alone
- scrollbars and sliders. Note that
+ scrollbars() and sliders(). Note that
starting from wxWidgets 2.1, scrolled windows send the
wxScrollWinEvent which does not derive from
wxCommandEvent, but from wxEvent directly - don't confuse these two kinds of
@library{wxcore}
@category{events}
- @seealso
- wxScrollBar, wxSlider, wxSpinButton, , wxScrollWinEvent, @ref
+ @see wxScrollBar, wxSlider, wxSpinButton, , wxScrollWinEvent, @ref
overview_eventhandlingoverview
*/
class wxScrollEvent : public wxCommandEvent
};
+
/**
@class wxIdleEvent
@wxheader{event.h}
happens and only then is the next idle event sent again. If you need to ensure
a continuous stream of idle events, you can either use
wxIdleEvent::RequestMore method in your handler or call
- wxWakeUpIdle periodically (for example from timer
+ wxWakeUpIdle() periodically (for example from timer
event), but note that both of these approaches (and especially the first one)
increase the system load and so should be avoided if possible.
@library{wxbase}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview, wxUpdateUIEvent, wxWindow::OnInternalIdle
+ @see @ref overview_eventhandlingoverview, wxUpdateUIEvent,
+ wxWindow::OnInternalIdle
*/
class wxIdleEvent : public wxEvent
{
};
+
/**
@class wxInitDialogEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview
+ @see @ref overview_eventhandlingoverview
*/
class wxInitDialogEvent : public wxEvent
{
};
+
/**
@class wxWindowDestroyEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview, wxWindowCreateEvent
+ @see @ref overview_eventhandlingoverview, wxWindowCreateEvent
*/
class wxWindowDestroyEvent : public wxCommandEvent
{
};
+
/**
@class wxNavigationKeyEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxWindow::Navigate, wxWindow::NavigateIn
+ @see wxWindow::Navigate, wxWindow::NavigateIn
*/
class wxNavigationKeyEvent
{
};
+
/**
@class wxMouseCaptureChangedEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxMouseCaptureLostEvent, @ref overview_eventhandlingoverview,
+ @see wxMouseCaptureLostEvent, @ref overview_eventhandlingoverview,
wxWindow::CaptureMouse, wxWindow::ReleaseMouse, wxWindow::GetCapture
*/
class wxMouseCaptureChangedEvent : public wxEvent
};
+
/**
@class wxCloseEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxWindow::Close, @ref overview_windowdeletionoverview "Window deletion overview"
+ @see wxWindow::Close, @ref overview_windowdeletionoverview "Window deletion
+ overview"
*/
class wxCloseEvent : public wxEvent
{
};
+
/**
@class wxMenuEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_wxcommandevent "Command events", @ref
+ @see @ref overview_wxcommandevent "Command events", @ref
overview_eventhandlingoverview
*/
class wxMenuEvent : public wxEvent
};
+
/**
@class wxEventBlocker
@wxheader{event.h}
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_eventhandlingoverview, wxEvtHandler
+ @see @ref overview_eventhandlingoverview, wxEvtHandler
*/
class wxEventBlocker : public wxEvtHandler
{
};
+
/**
@class wxEvtHandler
@wxheader{event.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_eventhandlingoverview
+ @see @ref overview_eventhandlingoverview
*/
class wxEvtHandler : public wxObject
{
};
+
/**
@class wxIconizeEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- @ref overview_eventhandlingoverview, wxTopLevelWindow::Iconize,
+ @see @ref overview_eventhandlingoverview, wxTopLevelWindow::Iconize,
wxTopLevelWindow::IsIconized
*/
class wxIconizeEvent : public wxEvent
};
+
/**
@class wxMoveEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxPoint, @ref overview_eventhandlingoverview
+ @see wxPoint, @ref overview_eventhandlingoverview
*/
class wxMoveEvent : public wxEvent
{
};
+
/**
@class wxEvent
@wxheader{event.h}
@library{wxbase}
@category{events}
- @seealso
- wxCommandEvent, wxMouseEvent
+ @see wxCommandEvent, wxMouseEvent
*/
class wxEvent : public wxObject
{
Returns a copy of the event.
Any event that is posted to the wxWidgets event system for later action (via
wxEvtHandler::AddPendingEvent or
- wxPostEvent) must implement this method. All wxWidgets
+ wxPostEvent()) must implement this method. All wxWidgets
events fully implement this method, but any derived events implemented by the
user should also implement this method just in case they (or some event
derived from them) are ever posted.
};
+
/**
@class wxSizeEvent
@wxheader{event.h}
@library{wxcore}
@category{events}
- @seealso
- wxSize, @ref overview_eventhandlingoverview
+ @see wxSize, @ref overview_eventhandlingoverview
*/
class wxSizeEvent : public wxEvent
{
};
+
/**
@class wxSetCursorEvent
@wxheader{event.h}
@library{wxcore}
@category{FIXME}
- @seealso
- ::wxSetCursor, wxWindow::wxSetCursor
+ @see ::wxSetCursor, wxWindow::wxSetCursor
*/
class wxSetCursorEvent : public wxEvent
{
*/
void SetCursor(const wxCursor& cursor);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: fdrepdlg.h
-// Purpose: documentation for wxFindDialogEvent class
+// Purpose: interface of wxFindDialogEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxFindReplaceData
@wxheader{fdrepdlg.h}
};
+
/**
@class wxFindReplaceDialog
@wxheader{fdrepdlg.h}
*/
const wxFindReplaceData* GetData() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: ffile.h
-// Purpose: documentation for wxFFile class
+// Purpose: interface of wxFFile
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{file}
- @seealso
- wxFFile::IsOpened
+ @see wxFFile::IsOpened
*/
class wxFFile
{
*/
FILE* fp() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: file.h
-// Purpose: documentation for wxTempFile class
+// Purpose: interface of wxTempFile
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxFile
@wxheader{file.h}
*/
int fd() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: fileconf.h
-// Purpose: documentation for wxFileConfig class
+// Purpose: interface of wxFileConfig
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxFileConfig::Save
+ @see wxFileConfig::Save
*/
class wxFileConfig : public wxConfigBase
{
@c SetUmask(0077).
This function doesn't do anything on non-Unix platforms.
- @see wxCHANGE_UMASK
+ @see wxCHANGE_UMASK()
*/
void SetUmask(int mode);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: filectrl.h
-// Purpose: documentation for wxFileCtrl class
+// Purpose: interface of wxFileCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxGenericDirCtrl
+ @see wxGenericDirCtrl
*/
class wxFileCtrl : public wxWindow
{
};
+
/**
@class wxFileCtrlEvent
@wxheader{filectrl.h}
*/
wxFileCtrlEvent::SetFiles(const wxArrayString files);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: filedlg.h
-// Purpose: documentation for wxFileDialog class
+// Purpose: interface of wxFileDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{cmndlg}
- @seealso
- @ref overview_wxfiledialogoverview "wxFileDialog overview", wxFileSelector
+ @see @ref overview_wxfiledialogoverview "wxFileDialog overview",
+ wxFileSelector()
*/
class wxFileDialog : public wxDialog
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: filefn.h
-// Purpose: documentation for wxPathList class
+// Purpose: interface of wxPathList
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{file}
- @seealso
- wxArrayString, wxStandardPaths, wxFileName
+ @see wxArrayString, wxStandardPaths, wxFileName
*/
class wxPathList : public wxArrayString
{
Note in fact that wxPathList can be used to store both relative and absolute
paths so that
if you Added() relative paths, then the current working directory
- (see wxGetCwd and wxSetWorkingDirectory)
+ (see wxGetCwd() and wxSetWorkingDirectory())
may affect the value returned by this function!
*/
wxString FindValidPath(const wxString& file) const;
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/**
Returns @true if the @a pattern matches the @e text; if @a dot_special is @true,
filenames beginning with a dot are not matched
- with wildcard characters. See wxIsWild.
+ with wildcard characters. See wxIsWild().
*/
bool wxMatchWild(const wxString& pattern, const wxString& text,
bool dot_special);
/**
- @b NB: This function is deprecated: use wxGetCwd instead.
+ @b NB: This function is deprecated: use wxGetCwd() instead.
Copies the current working directory into the buffer if supplied, or
copies the working directory into new storage (which you must delete
yourself) if the buffer is @NULL.
wxString wxPathOnly(const wxString& path);
/**
- Returns @true if the pattern contains wildcards. See wxMatchWild.
+ Returns @true if the pattern contains wildcards. See wxMatchWild().
*/
bool wxIsWild(const wxString& pattern);
bool wxIsAbsolutePath(const wxString& filename);
/**
- Returns the next file that matches the path passed to wxFindFirstFile.
- See wxFindFirstFile for an example.
+ Returns the next file that matches the path passed to wxFindFirstFile().
+ See wxFindFirstFile() for an example.
*/
wxString wxFindNextFile();
/**
This function does directory searching; returns the first file
- that matches the path @e spec, or the empty string. Use wxFindNextFile to
+ that matches the path @e spec, or the empty string. Use wxFindNextFile() to
get the next matching file. Neither will report the current directory "." or the
parent directory "..".
*/
/////////////////////////////////////////////////////////////////////////////
// Name: filename.h
-// Purpose: documentation for wxFileName class
+// Purpose: interface of wxFileName
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
a complete file name (such as when interpreting user input) you need to use
the static function wxFileName::DirExists
(or its identical variants wxDir::Exists and
- wxDirExists) and construct the wxFileName
+ wxDirExists()) and construct the wxFileName
instance accordingly. This will only work if the directory actually exists,
of course:
@library{wxbase}
@category{file}
- @seealso
- wxFileName::GetCwd
+ @see wxFileName::GetCwd
*/
class wxFileName
{
const bool operator operator==(const wxString& filename) const;
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: filepicker.h
-// Purpose: documentation for wxFilePickerCtrl class
+// Purpose: interface of wxFilePickerCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{miscpickers}
@appearance{filepickerctrl.png}
- @seealso
- wxFileDialog, wxFileDirPickerEvent
+ @see wxFileDialog, wxFileDirPickerEvent
*/
class wxFilePickerCtrl : public wxPickerBase
{
};
+
/**
@class wxDirPickerCtrl
@wxheader{filepicker.h}
@category{miscpickers}
@appearance{dirpickerctrl.png}
- @seealso
- wxDirDialog, wxFileDirPickerEvent
+ @see wxDirDialog, wxFileDirPickerEvent
*/
class wxDirPickerCtrl : public wxPickerBase
{
};
+
/**
@class wxFileDirPickerEvent
@wxheader{filepicker.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxfilepickerctrl
+ @see wxfilepickerctrl()
*/
class wxFileDirPickerEvent : public wxCommandEvent
{
*/
void SetPath(const wxString& path);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: filesys.h
-// Purpose: documentation for wxFileSystem class
+// Purpose: interface of wxFileSystem
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
This class provides an interface for opening files on different
file systems. It can handle absolute and/or local filenames.
- It uses a system of handlers to
+ It uses a system of handlers() to
provide access to user-defined virtual file systems.
@library{wxbase}
@category{vfs}
- @seealso
- wxFileSystemHandler, wxFSFile, Overview
+ @see wxFileSystemHandler, wxFSFile, Overview()
*/
class wxFileSystem : public wxObject
{
/**
This static function adds new handler into the list of
- handlers which provide access to virtual FS.
+ handlers() which provide access to virtual FS.
Note that if two handlers for the same protocol are added, the last one added
takes precedence.
*/
const wxString& file);
/**
- Works like wxFindFirstFile. Returns name of the first
+ Works like wxFindFirstFile(). Returns name of the first
filename (within filesystem's current path) that matches @e wildcard. @a flags
may be one of
wxFILE (only files), wxDIR (only directories) or 0 (both).
};
+
/**
@class wxFSFile
@wxheader{filesys.h}
@library{wxbase}
@category{vfs}
- @seealso
- wxFileSystemHandler, wxFileSystem, Overview
+ @see wxFileSystemHandler, wxFileSystem, Overview()
*/
class wxFSFile : public wxObject
{
};
+
/**
@class wxFileSystemHandler
@wxheader{filesys.h}
of opening the file: GetProtocol, GetLeftLocation, GetRightLocation,
GetAnchor, GetMimeTypeFromExt.
- Please have a look at overview if you don't know how locations
+ Please have a look at overview() if you don't know how locations
are constructed.
Also consult @ref overview_fs "list of available handlers".
@library{wxbase}
@category{vfs}
- @seealso
- wxFileSystem, wxFSFile, Overview
+ @see wxFileSystem, wxFSFile, Overview()
*/
class wxFileSystemHandler : public wxObject
{
virtual bool CanOpen(const wxString& location);
/**
- Works like wxFindFirstFile. Returns name of the first
+ Works like wxFindFirstFile(). Returns name of the first
filename (within filesystem's current path) that matches @e wildcard. @a flags
may be one of
wxFILE (only files), wxDIR (only directories) or 0 (both).
virtual wxFSFile* OpenFile(wxFileSystem& fs,
const wxString& location);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: font.h
-// Purpose: documentation for wxFont class
+// Purpose: interface of wxFont
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{gdi}
@stdobjects
- Objects:
- wxNullFont
- Pointers:
- wxNORMAL_FONT
+ ::Objects:, ::wxNullFont, ::Pointers:, ::wxNORMAL_FONT, ::wxSMALL_FONT,
+ ::wxITALIC_FONT, ::wxSWISS_FONT,
- wxSMALL_FONT
-
- wxITALIC_FONT
-
- wxSWISS_FONT
-
- @seealso
- @ref overview_wxfontoverview, wxDC::SetFont, wxDC::DrawText,
+ @see @ref overview_wxfontoverview, wxDC::SetFont, wxDC::DrawText,
wxDC::GetTextExtent, wxFontDialog, wxSystemSettings
*/
class wxFont : public wxGDIObject
*/
bool operator ==(const wxFont& font);
};
+
+
+/**
+ FIXME
+*/
+wxFont Objects:
+;
+
+/**
+ FIXME
+*/
+wxFont wxNullFont;
+
+/**
+ FIXME
+*/
+wxFont Pointers:
+;
+
+/**
+ FIXME
+*/
+wxFont wxNORMAL_FONT;
+
+/**
+ FIXME
+*/
+wxFont wxSMALL_FONT;
+
+/**
+ FIXME
+*/
+wxFont wxITALIC_FONT;
+
+/**
+ FIXME
+*/
+wxFont wxSWISS_FONT;
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: fontdlg.h
-// Purpose: documentation for wxFontDialog class
+// Purpose: interface of wxFontDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{cmndlg}
- @seealso
- Overview, wxFontData, wxGetFontFromUser
+ @see Overview(), wxFontData, wxGetFontFromUser()
*/
class wxFontDialog : public wxDialog
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: fontenum.h
-// Purpose: documentation for wxFontEnumerator class
+// Purpose: interface of wxFontEnumerator
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
wxFontEnumerator enumerates either all available fonts on the system or only
the ones with given attributes - either only fixed-width (suited for use in
programs such as terminal emulators and the like) or the fonts available in
- the given encoding.
+ the given encoding().
To do this, you just have to call one of EnumerateXXX() functions - either
wxFontEnumerator::EnumerateFacenames or
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_wxfontencodingoverview, @ref overview_samplefont "Font sample",
- wxFont, wxFontMapper
+ @see @ref overview_wxfontencodingoverview, @ref overview_samplefont "Font
+ sample", wxFont, wxFontMapper
*/
class wxFontEnumerator
{
virtual bool OnFontEncoding(const wxString& font,
const wxString& encoding);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: fontmap.h
-// Purpose: documentation for wxFontMapper class
+// Purpose: interface of wxFontMapper
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{misc}
- @seealso
- wxEncodingConverter, @ref overview_nonenglishoverview "Writing non-English
+ @see wxEncodingConverter, @ref overview_nonenglishoverview "Writing non-English
applications"
*/
class wxFontMapper
*/
void SetDialogTitle(const wxString& title);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: fontpicker.h
-// Purpose: documentation for wxFontPickerCtrl class
+// Purpose: interface of wxFontPickerCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{miscpickers}
@appearance{fontpickerctrl.png}
- @seealso
- wxFontDialog, wxFontPickerEvent
+ @see wxFontDialog, wxFontPickerEvent
*/
class wxFontPickerCtrl : public wxPickerBase
{
};
+
/**
@class wxFontPickerEvent
@wxheader{fontpicker.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxFontPickerCtrl
+ @see wxFontPickerCtrl
*/
class wxFontPickerEvent : public wxCommandEvent
{
*/
void SetFont(const wxFont& f);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: frame.h
-// Purpose: documentation for wxFrame class
+// Purpose: interface of wxFrame
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{managedwnd}
- @seealso
- wxMDIParentFrame, wxMDIChildFrame, wxMiniFrame, wxDialog
+ @see wxMDIParentFrame, wxMDIChildFrame, wxMiniFrame, wxDialog
*/
class wxFrame : public wxTopLevelWindow
{
*/
void SetToolBar(wxToolBar* toolBar);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: fs_mem.h
-// Purpose: documentation for wxMemoryFSHandler class
+// Purpose: interface of wxMemoryFSHandler
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxMemoryFSHandler::AddFileWithMimeType
+ @see wxMemoryFSHandler::AddFileWithMimeType
*/
class wxMemoryFSHandler : public wxFileSystemHandler
{
The @a type argument is one of @c wxBITMAP_TYPE_XXX constants.
Note that you must use a @a type value (aka image format)
that wxWidgets can save (e.g. JPG, PNG, see wxImage
- documentation)!
+ documentation())!
@see AddFileWithMimeType()
*/
Like AddFile(), but lets you explicitly
specify added file's MIME type. This version should be used whenever you know
the MIME type, because it makes accessing the files faster.
- This function is new since wxWidgets version 2.8.5
+
+ @wxsince{2.8.5}
@see AddFile()
*/
*/
static void RemoveFile(const wxString& filename);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: gauge.h
-// Purpose: documentation for wxGauge class
+// Purpose: interface of wxGauge
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{gauge.png}
- @seealso
- wxSlider, wxScrollBar
+ @see wxSlider, wxScrollBar
*/
class wxGauge : public wxControl
{
*/
void SetValue(int pos);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: gbsizer.h
-// Purpose: documentation for wxGBPosition class
+// Purpose: interface of wxGBPosition
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxGridBagSizer
@wxheader{gbsizer.h}
};
+
/**
@class wxGBSizerItem
@wxheader{gbsizer.h}
};
+
/**
@class wxGBSpan
@wxheader{gbsizer.h}
*/
bool operator operator==(const wxGBSpan& o) const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: gdicmn.h
-// Purpose: documentation for wxRealPoint class
+// Purpose: interface of wxRealPoint
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{data}
- @seealso
- wxPoint
+ @see wxPoint
*/
class wxRealPoint
{
};
+
/**
@class wxRect
@wxheader{gdicmn.h}
@library{wxcore}
@category{data}
- @seealso
- wxPoint, wxSize
+ @see wxPoint, wxSize
*/
class wxRect
{
};
+
/**
@class wxBrushList
@wxheader{gdicmn.h}
@library{wxcore}
@category{gdi}
- @seealso
- wxBrush
+ @see wxBrush
*/
class wxBrushList : public wxList
{
};
+
/**
@class wxPoint
@wxheader{gdicmn.h}
@library{wxcore}
@category{data}
- @seealso
- wxRealPoint
+ @see wxRealPoint
*/
class wxPoint
{
};
+
/**
@class wxColourDatabase
@wxheader{gdicmn.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxColour
+ @see wxColour
*/
class wxColourDatabase
{
};
+
/**
@class wxFontList
@wxheader{gdicmn.h}
@library{wxcore}
@category{gdi}
- @seealso
- wxFont
+ @see wxFont
*/
class wxFontList : public wxList
{
};
+
/**
@class wxSize
@wxheader{gdicmn.h}
@library{wxcore}
@category{data}
- @seealso
- wxPoint, wxRealPoint
+ @see wxPoint, wxRealPoint
*/
class wxSize
{
};
+
/**
@class wxPenList
@wxheader{gdicmn.h}
@library{wxcore}
@category{gdi}
- @seealso
- wxPen
+ @see wxPen
*/
class wxPenList
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
for which they exist, i.e. Windows and OS2) or from an XPM file. It allows to
avoid using @c #ifdefs when creating icons.
- @see @ref overview_wxbitmapoverview, wxBITMAP
+ @see @ref overview_wxbitmapoverview, wxBITMAP()
*/
wxICON();
for which they exist, i.e. Windows and OS2) or from an XPM file. It allows to
avoid using @c #ifdefs when creating bitmaps.
- @see @ref overview_wxbitmapoverview, wxICON
+ @see @ref overview_wxbitmapoverview, wxICON()
*/
#define wxBITMAP() /* implementation is private */
/////////////////////////////////////////////////////////////////////////////
// Name: gdiobj.h
-// Purpose: documentation for wxGDIObject class
+// Purpose: interface of wxGDIObject
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxPen, wxBrush, wxFont
+ @see wxPen, wxBrush, wxFont
*/
class wxGDIObject : public wxObject
{
*/
wxGDIObject();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: glcanvas.h
-// Purpose: documentation for wxGLContext class
+// Purpose: interface of wxGLContext
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxgl}
@category{gl}
- @seealso
- wxGLCanvas
+ @see wxGLCanvas
*/
class wxGLContext : public wxObject
{
};
+
/**
@class wxGLCanvas
@wxheader{glcanvas.h}
@library{wxgl}
@category{gl}
- @seealso
- wxGLContext
+ @see wxGLContext
*/
class wxGLCanvas : public wxWindow
{
*/
bool SwapBuffers();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: graphics.h
-// Purpose: documentation for wxGraphicsPath class
+// Purpose: interface of wxGraphicsPath
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxGraphicsObject
@wxheader{graphics.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxGraphicsBrush, wxGraphicsPen, wxGraphicsMatrix, wxGraphicsPath
+ @see wxGraphicsBrush, wxGraphicsPen, wxGraphicsMatrix, wxGraphicsPath
*/
class wxGraphicsObject : public wxObject
{
};
+
/**
@class wxGraphicsContext
@wxheader{graphics.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxGraphicsRenderer:: CreateContext
+ @see wxGraphicsRenderer:: CreateContext
*/
class wxGraphicsContext : public wxGraphicsObject
{
};
+
/**
@class wxGraphicsRenderer
@wxheader{graphics.h}
};
+
/**
@class wxGraphicsBrush
@wxheader{graphics.h}
};
+
/**
@class wxGraphicsFont
@wxheader{graphics.h}
};
+
/**
@class wxGraphicsPen
@wxheader{graphics.h}
};
+
/**
@class wxGraphicsMatrix
@wxheader{graphics.h}
*/
void Translate(wxDouble dx, wxDouble dy);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: grid.h
-// Purpose: documentation for wxGridCellFloatRenderer class
+// Purpose: interface of wxGridCellFloatRenderer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellStringRenderer,
+ @see wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellStringRenderer,
wxGridCellBoolRenderer
*/
class wxGridCellFloatRenderer : public wxGridCellStringRenderer
};
+
/**
@class wxGridTableBase
@wxheader{grid.h}
};
+
/**
@class wxGridCellEditor
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellTextEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
+ @see wxGridCellTextEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
wxGridCellNumberEditor, wxGridCellChoiceEditor
*/
class wxGridCellEditor
};
+
/**
@class wxGridCellTextEditor
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
+ @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
wxGridCellNumberEditor, wxGridCellChoiceEditor
*/
class wxGridCellTextEditor : public wxGridCellEditor
};
+
/**
@class wxGridCellStringRenderer
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellFloatRenderer,
+ @see wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellFloatRenderer,
wxGridCellBoolRenderer
*/
class wxGridCellStringRenderer : public wxGridCellRenderer
};
+
/**
@class wxGridCellChoiceEditor
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
+ @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
wxGridCellTextEditor, wxGridCellNumberEditor
*/
class wxGridCellChoiceEditor : public wxGridCellEditor
};
+
/**
@class wxGridEditorCreatedEvent
@wxheader{grid.h}
};
+
/**
@class wxGridRangeSelectEvent
@wxheader{grid.h}
};
+
/**
@class wxGridCellRenderer
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellStringRenderer, wxGridCellNumberRenderer, wxGridCellFloatRenderer,
- wxGridCellBoolRenderer
+ @see wxGridCellStringRenderer, wxGridCellNumberRenderer,
+ wxGridCellFloatRenderer, wxGridCellBoolRenderer
*/
class wxGridCellRenderer
{
};
+
/**
@class wxGridCellNumberEditor
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
+ @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
wxGridCellTextEditor, wxGridCellChoiceEditor
*/
class wxGridCellNumberEditor : public wxGridCellTextEditor
};
+
/**
@class wxGridSizeEvent
@wxheader{grid.h}
};
+
/**
@class wxGridCellNumberRenderer
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
+ @see wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
wxGridCellBoolRenderer
*/
class wxGridCellNumberRenderer : public wxGridCellStringRenderer
};
+
/**
@class wxGridCellAttr
@wxheader{grid.h}
};
+
/**
@class wxGridCellBoolRenderer
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
+ @see wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
wxGridCellNumberRenderer
*/
class wxGridCellBoolRenderer : public wxGridCellRenderer
};
+
/**
@class wxGridEvent
@wxheader{grid.h}
};
+
/**
@class wxGridCellFloatEditor
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellEditor, wxGridCellNumberEditor, wxGridCellBoolEditor,
+ @see wxGridCellEditor, wxGridCellNumberEditor, wxGridCellBoolEditor,
wxGridCellTextEditor, wxGridCellChoiceEditor
*/
class wxGridCellFloatEditor : public wxGridCellTextEditor
};
+
/**
@class wxGrid
@wxheader{grid.h}
@library{wxadv}
@category{miscwnd}
- @seealso
- @ref overview_gridoverview "wxGrid overview"
+ @see @ref overview_gridoverview "wxGrid overview"
*/
class wxGrid : public wxScrolledWindow
{
};
+
/**
@class wxGridCellBoolEditor
@wxheader{grid.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxGridCellEditor, wxGridCellFloatEditor, wxGridCellNumberEditor,
+ @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellNumberEditor,
wxGridCellTextEditor, wxGridCellChoiceEditor
*/
class wxGridCellBoolEditor : public wxGridCellEditor
};
+
/**
@class wxGridUpdateLocker
@wxheader{grid.h}
*/
void Create(wxGrid* grid);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: hash.h
-// Purpose: documentation for wxHashTable class
+// Purpose: interface of wxHashTable
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{containers}
- @seealso
- wxList
+ @see wxList
*/
class wxHashTable : public wxObject
{
void Put(const char* key, wxObject* object);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: hashmap.h
-// Purpose: documentation for wxHashMap class
+// Purpose: interface of wxHashMap
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
size_type size() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: hashset.h
-// Purpose: documentation for wxHashSet class
+// Purpose: interface of wxHashSet
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
size_type size() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: help.h
-// Purpose: documentation for wxHelpController class
+// Purpose: interface of wxHelpController
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
The default browser is Netscape Navigator. The 'help' sample shows its use.
wxWinceHelpController, for controlling a simple @c .htm help controller for
Windows CE applications.
- wxHtmlHelpController, a sophisticated help controller using wxHTML, in
+ wxHtmlHelpController, a sophisticated help controller using wxHTML(), in
a similar style to the Microsoft HTML Help viewer and using some of the same
files.
Although it has an API compatible with other help controllers, it has more
@library{wxbase}
@category{help}
- @seealso
- wxHtmlHelpController, wxHTML
+ @see wxHtmlHelpController, wxHTML()
*/
class wxHelpController : public wxObject
{
*/
virtual void SetViewer(const wxString& viewer, long flags);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/helpctrl.h
-// Purpose: documentation for wxHtmlHelpController class
+// Purpose: interface of wxHtmlHelpController
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
wxHTML uses Microsoft's HTML Help Workshop project files (.hhp, .hhk, .hhc) as
its
- native format. The file format is described here.
+ native format. The file format is described here().
Have a look at docs/html/ directory where sample project files are stored.
You can use Tex2RTF to produce these files when generating HTML, if you set @b
@library{wxhtml}
@category{help}
- @seealso
- @ref overview_wxhelpcontroller "Information about wxBestHelpController",
+ @see @ref overview_wxhelpcontroller "Information about wxBestHelpController",
wxHtmlHelpFrame, wxHtmlHelpDialog, wxHtmlHelpWindow, wxHtmlModalHelp
*/
class wxHtmlHelpController
};
+
/**
@class wxHtmlModalHelp
@headerfile helpctrl.h wx/html/helpctrl.h
const wxString& topic = wxEmptyString,
int style = wxHF_DEFAULT_STYLE | wxHF_DIALOG | wxHF_MODAL);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/helpdata.h
-// Purpose: documentation for wxHtmlHelpData class
+// Purpose: interface of wxHtmlHelpData
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
void SetTempDir(const wxString& path);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/helpdlg.h
-// Purpose: documentation for wxHtmlHelpDialog class
+// Purpose: interface of wxHtmlHelpDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
void WriteCustomization(wxConfigBase* cfg,
const wxString& path = wxEmptyString);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/helpfrm.h
-// Purpose: documentation for wxHtmlHelpFrame class
+// Purpose: interface of wxHtmlHelpFrame
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
void WriteCustomization(wxConfigBase* cfg,
const wxString& path = wxEmptyString);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/helpwnd.h
-// Purpose: documentation for wxHtmlHelpWindow class
+// Purpose: interface of wxHtmlHelpWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
void WriteCustomization(wxConfigBase* cfg,
const wxString& path = wxEmptyString);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/htmlcell.h
-// Purpose: documentation for wxHtmlColourCell class
+// Purpose: interface of wxHtmlColourCell
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxHtmlWidgetCell
@headerfile htmlcell.h wx/html/htmlcell.h
};
+
/**
@class wxHtmlCell
@headerfile htmlcell.h wx/html/htmlcell.h
@library{wxhtml}
@category{FIXME}
- @seealso
- @ref overview_cells "Cells Overview", wxHtmlContainerCell
+ @see @ref overview_cells "Cells Overview", wxHtmlContainerCell
*/
class wxHtmlCell : public wxObject
{
};
+
/**
@class wxHtmlContainerCell
@headerfile htmlcell.h wx/html/htmlcell.h
@library{wxhtml}
@category{FIXME}
- @seealso
- @ref overview_cells "Cells Overview"
+ @see @ref overview_cells "Cells Overview"
*/
class wxHtmlContainerCell : public wxHtmlCell
{
};
+
/**
@class wxHtmlLinkInfo
@headerfile htmlcell.h wx/html/htmlcell.h
*/
wxString GetTarget();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/htmlfilt.h
-// Purpose: documentation for wxHtmlFilter class
+// Purpose: interface of wxHtmlFilter
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxhtml}
@category{FIXME}
- @seealso
- Overview
+ @see Overview()
*/
class wxHtmlFilter : public wxObject
{
*/
wxString ReadFile(const wxFSFile& file);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/htmlpars.h
-// Purpose: documentation for wxHtmlTagHandler class
+// Purpose: interface of wxHtmlTagHandler
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxhtml}
@category{html}
- @seealso
- Overview, wxHtmlTag
+ @see Overview(), wxHtmlTag
*/
class wxHtmlTagHandler : public wxObject
{
};
+
/**
@class wxHtmlParser
@headerfile htmlpars.h wx/html/htmlpars.h
@library{wxhtml}
@category{html}
- @seealso
- @ref overview_cells "Cells Overview", @ref overview_handlers "Tag Handlers
+ @see @ref overview_cells "Cells Overview", @ref overview_handlers "Tag Handlers
Overview", wxHtmlTag
*/
class wxHtmlParser
*/
void StopParsing();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/htmltag.h
-// Purpose: documentation for wxHtmlTag class
+// Purpose: interface of wxHtmlTag
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
wxString ScanParam(const wxString& par, const wxChar* format,
void* value) const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/htmlwin.h
-// Purpose: documentation for wxHtmlWindow class
+// Purpose: interface of wxHtmlWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxhtml}
@category{html}
- @seealso
- wxHtmlLinkEvent, wxHtmlCellEvent
+ @see wxHtmlLinkEvent, wxHtmlCellEvent
*/
class wxHtmlWindow : public wxScrolledWindow
{
};
+
/**
@class wxHtmlLinkEvent
@headerfile htmlwin.h wx/html/htmlwin.h
};
+
/**
@class wxHtmlCellEvent
@headerfile htmlwin.h wx/html/htmlwin.h
*/
bool SetLinkClicked(bool linkclicked);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/htmprint.h
-// Purpose: documentation for wxHtmlDCRenderer class
+// Purpose: interface of wxHtmlDCRenderer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxHtmlEasyPrinting
@headerfile htmprint.h wx/html/htmprint.h
};
+
/**
@class wxHtmlPrintout
@headerfile htmprint.h wx/html/htmprint.h
float right = 25.2,
float spaces = 5);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: html/winpars.h
-// Purpose: documentation for wxHtmlTagsModule class
+// Purpose: interface of wxHtmlTagsModule
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxhtml}
@category{FIXME}
- @seealso
- @ref overview_handlers "Tag Handlers", wxHtmlTagHandler, wxHtmlWinTagHandler,
+ @see @ref overview_handlers "Tag Handlers", wxHtmlTagHandler,
+ wxHtmlWinTagHandler,
*/
class wxHtmlTagsModule : public wxModule
{
};
+
/**
@class wxHtmlWinTagHandler
@headerfile winpars.h wx/html/winpars.h
};
+
/**
@class wxHtmlWinParser
@headerfile winpars.h wx/html/winpars.h
@library{wxhtml}
@category{html}
- @seealso
- @ref overview_handlers "Handlers overview"
+ @see @ref overview_handlers "Handlers overview"
*/
class wxHtmlWinParser : public wxHtmlParser
{
//@}
/**
- Adds module to the list of wxHtmlWinParser tag handler.
+ Adds module() to the list of wxHtmlWinParser tag handler.
*/
static void AddModule(wxHtmlTagsModule module);
/**
Closes the container, sets actual container to the parent one
- and returns pointer to it (see Overview).
+ and returns pointer to it (see Overview()).
*/
wxHtmlContainerCell* CloseContainer();
int GetCharWidth() const;
/**
- Returns pointer to the currently opened container (see Overview).
+ Returns pointer to the currently opened container (see Overview()).
Common use:
*/
wxHtmlContainerCell* GetContainer() const;
wxHtmlWindow* GetWindow();
/**
- Opens new container and returns pointer to it (see Overview).
+ Opens new container and returns pointer to it (see Overview()).
*/
wxHtmlContainerCell* OpenContainer();
*/
void SetLinkColor(const wxColour& clr);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: htmllbox.h
-// Purpose: documentation for wxHtmlListBox class
+// Purpose: interface of wxHtmlListBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{htmllistbox.png}
- @seealso
- wxSimpleHtmlListBox
+ @see wxSimpleHtmlListBox
*/
class wxHtmlListBox : public wxVListBox
{
};
+
/**
@class wxSimpleHtmlListBox
@wxheader{htmllbox.h}
@category{ctrl}
@appearance{simplehtmllistbox.png}
- @seealso
- wxSimpleHtmlListBox::Create
+ @see wxSimpleHtmlListBox::Create
*/
class wxSimpleHtmlListBox : public wxHtmlListBox
{
const wxString& name = "simpleHtmlListBox");
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: hyperlink.h
-// Purpose: documentation for wxHyperlinkEvent class
+// Purpose: interface of wxHyperlinkEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxHyperlinkCtrl
@wxheader{hyperlink.h}
clicks on the hyperlink, a wxHyperlinkEvent is
sent but if that event is not handled (or it's skipped; see
wxEvent::Skip), then a call to
- wxLaunchDefaultBrowser is done with the
+ wxLaunchDefaultBrowser() is done with the
hyperlink's URL.
Note that standard wxWindow functions like wxWindow::SetBackgroundColour,
@category{ctrl}
@appearance{hyperlinkctrl.png}
- @seealso
- wxURL, wxHyperlinkEvent
+ @see wxURL, wxHyperlinkEvent
*/
class wxHyperlinkCtrl : public wxControl
{
long style,
const wxString& name = "hyperlink");
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: icon.h
-// Purpose: documentation for wxIcon class
+// Purpose: interface of wxIcon
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{gdi}
@stdobjects
- Objects:
- wxNullIcon
+ ::Objects:, ::wxNullIcon,
- @seealso
- @ref overview_wxbitmapoverview "Bitmap and icon overview", @ref
+ @see @ref overview_wxbitmapoverview "Bitmap and icon overview", @ref
overview_supportedbitmapformats "supported bitmap file formats", wxDC::DrawIcon, wxCursor
*/
class wxIcon : public wxBitmap
public:
//@{
/**
- Loads an icon from the specified location.
+ Loads an icon from the specified location().
@param bits
Specifies an array of pixel values.
*/
wxIcon operator =(const wxIcon& icon);
};
+
+
+/**
+ FIXME
+*/
+wxIcon Objects:
+;
+
+/**
+ FIXME
+*/
+wxIcon wxNullIcon;
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: iconbndl.h
-// Purpose: documentation for wxIconBundle class
+// Purpose: interface of wxIconBundle
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{FIXME}
@stdobjects
- wxNullIconBundle
+ ::wxNullIconBundle,
*/
class wxIconBundle : public wxGDIObject
{
*/
bool operator ==(const wxIconBundle& ic);
};
+
+
+/**
+ FIXME
+*/
+wxIconBundle wxNullIconBundle;
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: iconloc.h
-// Purpose: documentation for wxIconLocation class
+// Purpose: interface of wxIconLocation
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxIcon, wxFileType::GetIcon
+ @see wxIcon, wxFileType::GetIcon
*/
class wxIconLocation
{
*/
bool IsOk() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: image.h
-// Purpose: documentation for wxImageHandler class
+// Purpose: interface of wxImageHandler
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxImage, wxInitAllImageHandlers
+ @see wxImage, wxInitAllImageHandlers()
*/
class wxImageHandler : public wxObject
{
};
+
/**
@class wxImage
@wxheader{image.h}
@library{wxcore}
@category{gdi}
- @seealso
- wxBitmap, wxInitAllImageHandlers
+ @see wxBitmap, wxInitAllImageHandlers()
*/
class wxImage : public wxObject
{
This function is called by wxWidgets on startup, and shouldn't be called by
the user.
- @see wxImageHandler, wxInitAllImageHandlers, wxQuantize
+ @see wxImageHandler, wxInitAllImageHandlers(), wxQuantize
*/
static void InitStandardHandlers();
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: imaglist.h
-// Purpose: documentation for wxImageList class
+// Purpose: interface of wxImageList
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{gdi}
- @seealso
- wxTreeCtrl, wxListCtrl
+ @see wxTreeCtrl, wxListCtrl
*/
class wxImageList : public wxObject
{
bool Replace(int index, const wxIcon& icon);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: init.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/**
-Free resources allocated by a successful call to wxEntryStart.
+Free resources allocated by a successful call to wxEntryStart().
*/
void wxEntryCleanup();
/////////////////////////////////////////////////////////////////////////////
// Name: intl.h
-// Purpose: documentation for wxLocale class
+// Purpose: interface of wxLocale
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_internationalization, @ref overview_sampleinternat "Internat
+ @see @ref overview_internationalization, @ref overview_sampleinternat "Internat
sample", wxXLocale
*/
class wxLocale
@a msgIdLanguage and @e msgIdCharset.
@a msgIdLanguage specifies the language of "msgid" strings in source code
(i.e. arguments to GetString(),
- wxGetTranslation and the
- _ macro). It is used if AddCatalog cannot find any
+ wxGetTranslation() and the
+ _() macro). It is used if AddCatalog cannot find any
catalog for current language: if the language is same as source code language,
then strings from source code are used instead.
@a msgIdCharset lets you specify the charset used for msgids in sources
const wxString& domain = wxEmptyString) const;
/**
- Returns wxLanguage constant of current language.
+ Returns wxLanguage() constant of current language.
Note that you can call this function only if you used the form of
Init() that takes wxLanguage argument.
*/
message catalog is found @a origString is returned if 'n == 1',
otherwise @e origString2.
See GNU gettext manual for additional information on plural forms handling.
- This method is called by the wxGetTranslation
- function and _ macro.
+ This method is called by the wxGetTranslation()
+ function and _() macro.
@remarks Domains are searched in the last to first order, i.e. catalogs
added later override those added before.
/**
Tries to detect the user's default font encoding.
- Returns wxFontEncoding value or
+ Returns wxFontEncoding() value or
@b wxFONTENCODING_SYSTEM if it couldn't be determined.
*/
static wxFontEncoding GetSystemEncoding() const;
/**
Tries to detect the user's default language setting.
- Returns wxLanguage value or
+ Returns wxLanguage() value or
@b wxLANGUAGE_UNKNOWN if the language-guessing algorithm failed.
*/
static int GetSystemLanguage() const;
FindLanguageInfo() to obtain its
wxLanguageInfo structure. See AddLanguage() for
the wxLanguageInfo description.
- This function is new since wxWidgets version 2.7.1.
+
+ @wxsince{2.7.1}.
*/
static bool IsAvailable(int lang);
};
+
/**
@class wxXLocale
@wxheader{intl.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxLocale
+ @see wxLocale
*/
class wxXLocale
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/**
- This macro is identical to _ but for the plural variant
- of wxGetTranslation.
+ This macro is identical to _() but for the plural variant
+ of wxGetTranslation().
*/
#define const wxString wxPLURAL(const wxString& sing,
const wxString& plur,
value of its argument.
However it does have a purpose which is to mark the literal strings for the
extraction into the message catalog created by @c xgettext program. Usually
- this is achieved using _ but that macro not only marks
+ this is achieved using _() but that macro not only marks
the string for extraction but also expands into a
- wxGetTranslation function call which means that it
+ wxGetTranslation() function call which means that it
cannot be used in some situations, notably for static array
initialization.
Here is an example which should make it more clear: suppose that you have a
#define const wxChar* wxTRANSLATE(const char* s) /* implementation is private */
/**
- This macro expands into a call to wxGetTranslation
+ This macro expands into a call to wxGetTranslation()
function, so it marks the message for the extraction by @c xgettext just as
- wxTRANSLATE does, but also returns the translation of
+ wxTRANSLATE() does, but also returns the translation of
the string for the current locale during execution.
- Don't confuse this macro with _T!
+ Don't confuse this macro with _T()!
*/
const wxString _(const wxString& s);
//@{
/**
This function returns the translation of string @a str in the current
- locale. If the string is not found in any of the loaded
+ locale(). If the string is not found in any of the loaded
message catalogs (see @ref overview_internationalization "internationalization
overview"), the
original string is returned. In debug build, an error message is logged -- this
@a domain is specified then only that domain/catalog is searched
for a matching string. As this function
is used very often, an alternative (and also common in Unix world) syntax is
- provided: the _ macro is defined to do the same thing
+ provided: the _() macro is defined to do the same thing
as wxGetTranslation.
The second form is used when retrieving translation of string that has
different singular and plural form in English or different plural forms in some
otherwise @e strPlural.
See GNU gettext manual
for additional information on plural forms handling. For a shorter alternative
- see the wxPLURAL macro.
+ see the wxPLURAL() macro.
Both versions call wxLocale::GetString.
Note that this function is not suitable for literal strings in Unicode
builds, since the literal strings must be enclosed into
- _T or wxT macro which makes them
+ _T() or wxT() macro which makes them
unrecognised by @c xgettext, and so they are not extracted to the message
- catalog. Instead, use the _ and
- wxPLURAL macro for all literal strings.
+ catalog. Instead, use the _() and
+ wxPLURAL() macro for all literal strings.
*/
const wxString wxGetTranslation(const wxString& str,
const wxString& domain = wxEmptyString);
/////////////////////////////////////////////////////////////////////////////
// Name: ipc.h
-// Purpose: documentation for wxConnection class
+// Purpose: interface of wxConnection
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxClient, wxServer, @ref overview_ipcoverview "Interprocess communications
+ @see wxClient, wxServer, @ref overview_ipcoverview "Interprocess communications
overview"
*/
class wxConnection : public wxObject
};
+
/**
@class wxClient
@wxheader{ipc.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxServer, wxConnection, @ref overview_ipcoverview "Interprocess communications
- overview"
+ @see wxServer, wxConnection, @ref overview_ipcoverview "Interprocess
+ communications overview"
*/
class wxClient : public wxObject
{
};
+
/**
@class wxServer
@wxheader{ipc.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxClient, wxConnection, IPC, overview
+ @see wxClient, wxConnection, IPC, overview()
*/
class wxServer
{
*/
virtual wxConnectionBase* OnAcceptConnection(const wxString& topic);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: joystick.h
-// Purpose: documentation for wxJoystick class
+// Purpose: interface of wxJoystick
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxadv}
@category{FIXME}
- @seealso
- wxJoystickEvent
+ @see wxJoystickEvent
*/
class wxJoystick : public wxObject
{
*/
void SetMovementThreshold(int threshold);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: layout.h
-// Purpose: documentation for wxIndividualLayoutConstraint class
+// Purpose: interface of wxIndividualLayoutConstraint
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{winlayout}
- @seealso
- @ref overview_constraintsoverview "Overview and examples", wxLayoutConstraints,
- wxWindow::SetConstraints.
+ @see @ref overview_constraintsoverview "Overview and examples",
+ wxLayoutConstraints, wxWindow::SetConstraints.
*/
class wxIndividualLayoutConstraint : public wxObject
{
};
+
/**
@class wxLayoutConstraints
@wxheader{layout.h}
- @b Note: constraints are now deprecated and you should use sizers instead.
+ @b Note: constraints are now deprecated and you should use sizers() instead.
Objects of this class can be associated with a window to define its
layout constraints, with respect to siblings or its parent.
@library{wxcore}
@category{winlayout}
- @seealso
- @ref overview_constraintsoverview "Overview and examples",
+ @see @ref overview_constraintsoverview "Overview and examples",
wxIndividualLayoutConstraint, wxWindow::SetConstraints
*/
class wxLayoutConstraints : public wxObject
Constraint for the width.
*/
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: laywin.h
-// Purpose: documentation for wxLayoutAlgorithm class
+// Purpose: interface of wxLayoutAlgorithm
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxadv}
@category{winlayout}
- @seealso
- wxSashEvent, wxSashLayoutWindow, @ref overview_eventhandlingoverview
+ @see wxSashEvent, wxSashLayoutWindow, @ref overview_eventhandlingoverview
*/
class wxLayoutAlgorithm : public wxObject
{
};
+
/**
@class wxSashLayoutWindow
@wxheader{laywin.h}
@library{wxadv}
@category{miscwnd}
- @seealso
- wxLayoutAlgorithm, wxSashWindow, @ref overview_eventhandlingoverview
+ @see wxLayoutAlgorithm, wxSashWindow, @ref overview_eventhandlingoverview
*/
class wxSashLayoutWindow : public wxSashWindow
{
};
+
/**
@class wxQueryLayoutInfoEvent
@wxheader{laywin.h}
@library{wxadv}
@category{events}
- @seealso
- wxCalculateLayoutEvent, wxSashLayoutWindow, wxLayoutAlgorithm.
+ @see wxCalculateLayoutEvent, wxSashLayoutWindow, wxLayoutAlgorithm.
*/
class wxQueryLayoutInfoEvent : public wxEvent
{
};
+
/**
@class wxCalculateLayoutEvent
@wxheader{laywin.h}
@library{wxadv}
@category{events}
- @seealso
- wxQueryLayoutInfoEvent, wxSashLayoutWindow, wxLayoutAlgorithm.
+ @see wxQueryLayoutInfoEvent, wxSashLayoutWindow, wxLayoutAlgorithm.
*/
class wxCalculateLayoutEvent : public wxEvent
{
*/
void SetRect(const wxRect& rect);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: link.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/**
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.
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
/**
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.
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()"
of your app). The @c moduleName is the name of the module you want to
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 */
/////////////////////////////////////////////////////////////////////////////
// Name: list.h
-// Purpose: documentation for wxList<T> class
+// Purpose: interface of wxList<T>
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxArrayT, wxVectorT
+ @see wxArrayT(), wxVectorT()
*/
class wxList<T>
{
};
+
/**
@class wxNode
@wxheader{list.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxList, wxHashTable
+ @see wxList, wxHashTable
*/
class wxNode
{
*/
void SetData(T* data);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: listbook.h
-// Purpose: documentation for wxListbook class
+// Purpose: interface of wxListbook
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{miscwnd}
- @seealso
- wxBookCtrl, wxNotebook, @ref overview_samplenotebook "notebook sample"
+ @see wxBookCtrl(), wxNotebook, @ref overview_samplenotebook "notebook sample"
*/
class wxListbook : public wxBookCtrl overview
{
const wxString& name = wxEmptyStr);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: listbox.h
-// Purpose: documentation for wxListBox class
+// Purpose: interface of wxListBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{listbox.png}
- @seealso
- wxChoice, wxComboBox, wxListCtrl, wxCommandEvent
+ @see wxChoice, wxComboBox, wxListCtrl, wxCommandEvent
*/
class wxListBox : public wxControlWithItems
{
/**
Returns the item located at @e point, or @c wxNOT_FOUND if there
is no item located at @e point.
- This function is new since wxWidgets version 2.7.0. It is currently implemented
+
+ @wxsince{2.7.0}. It is currently implemented
for wxMSW, wxMac and wxGTK2
ports.
void SetFirstItem(const wxString& string);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: listctrl.h
-// Purpose: documentation for wxListCtrl class
+// Purpose: interface of wxListCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@b Mac Note: Starting with 2.8, wxListCtrl uses a native implementation for
report mode, and uses a generic implementation for other modes. You can use the
generic implementation for report mode as well by setting the
- mac.listctrl.always_use_generic wxSystemOption to
+ mac.listctrl.always_use_generic wxSystemOption() to
1.
@beginStyleTable
@category{ctrl}
@appearance{listctrl.png}
- @seealso
- @ref overview_wxlistctrloverview "wxListCtrl overview", wxListView, wxListBox,
- wxTreeCtrl, wxImageList, wxListEvent, wxListItem
+ @see @ref overview_wxlistctrloverview "wxListCtrl overview", wxListView,
+ wxListBox, wxTreeCtrl, wxImageList, wxListEvent, wxListItem
*/
class wxListCtrl : public wxControl
{
for GetItemRect().
@a code can be one of @c wxLIST_RECT_BOUNDS,
@c wxLIST_RECT_ICON or @c wxLIST_RECT_LABEL.
- This function is new since wxWidgets version 2.7.0
+
+ @wxsince{2.7.0}
*/
bool GetSubItemRect(long item, long subItem, wxRect& rect,
int code = wxLIST_RECT_BOUNDS) const;
be either an integer or a pointer cast to the @c wxUIntPtr type which is
guaranteed to be large enough to be able to contain all integer types and
pointers.
- This function is new since wxWidgets version 2.8.4
+
+ @wxsince{2.8.4}
*/
bool SetItemPtrData(long item, wxUIntPtr data);
};
+
/**
@class wxListEvent
@wxheader{listctrl.h}
@library{wxbase}
@category{events}
- @seealso
- wxListCtrl
+ @see wxListCtrl
*/
class wxListEvent : public wxNotifyEvent
{
};
+
/**
@class wxListItemAttr
@wxheader{listctrl.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxlistctrloverview "wxListCtrl overview", wxListCtrl, wxListItem
+ @see @ref overview_wxlistctrloverview "wxListCtrl overview", wxListCtrl,
+ wxListItem
*/
class wxListItemAttr
{
};
+
/**
@class wxListView
@wxheader{listctrl.h}
@category{ctrl}
@appearance{listview.png}
- @seealso
- wxListView::SetColumnImage
+ @see wxListView::SetColumnImage
*/
class wxListView : public wxListCtrl
{
};
+
/**
@class wxListItem
@wxheader{listctrl.h}
*/
void SetWidth(int width);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: log.h
-// Purpose: documentation for wxLogWindow class
+// Purpose: interface of wxLogWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{logging}
- @seealso
- wxLogTextCtrl
+ @see wxLogTextCtrl
*/
class wxLogWindow : public wxLogInterposer
{
};
+
/**
@class wxLogInterposerTemp
@wxheader{log.h}
};
+
/**
@class wxLogChain
@wxheader{log.h}
};
+
/**
@class wxLogGui
@wxheader{log.h}
};
+
/**
@class wxLogStream
@wxheader{log.h}
@library{wxbase}
@category{logging}
- @seealso
- wxLogStderr, wxStreamToTextRedirector
+ @see wxLogStderr, wxStreamToTextRedirector
*/
class wxLogStream : public wxLog
{
};
+
/**
@class wxLogStderr
@wxheader{log.h}
@library{wxbase}
@category{logging}
- @seealso
- wxLogStream
+ @see wxLogStream
*/
class wxLogStderr : public wxLog
{
};
+
/**
@class wxLogBuffer
@wxheader{log.h}
};
+
/**
@class wxLogInterposer
@wxheader{log.h}
};
+
/**
@class wxLogTextCtrl
@wxheader{log.h}
@library{wxbase}
@category{logging}
- @seealso
- wxTextCtrl, wxStreamToTextRedirector
+ @see wxTextCtrl, wxStreamToTextRedirector
*/
class wxLogTextCtrl : public wxLog
{
};
+
/**
@class wxLog
@wxheader{log.h}
@library{wxcore}
@category{logging}
- @seealso
- wxLog::RemoveTraceMask, wxLog::GetTraceMasks
+ @see wxLog::RemoveTraceMask, wxLog::GetTraceMasks
*/
class wxLog
{
public:
/**
Add the @a mask to the list of allowed masks for
- wxLogTrace.
+ wxLogTrace().
@see RemoveTraceMask(), GetTraceMasks()
*/
without writing a new log target class (which, aside of being a matter of
several minutes, allows you to do anything you want).
The verbose messages are the trace messages which are not disabled in the
- release mode and are generated by wxLogVerbose. They
+ release mode and are generated by wxLogVerbose(). They
are not normally shown to the user because they present little interest, but
may be activated, for example, in order to help the user find some program
problem.
the (application global) @e trace mask. There are two ways to specify it:
either by using SetTraceMask() and
GetTraceMask() and using
- wxLogTrace which takes an integer mask or by using
+ wxLogTrace() which takes an integer mask or by using
AddTraceMask() for string trace masks.
The difference between bit-wise and string trace masks is that a message using
integer trace mask will only be logged if all bits of the mask are set in the
the preferred way of working with trace messages. The integer trace mask is
kept for compatibility and for additional (but very rarely needed) flexibility
only.
- The standard trace masks are given in wxLogTrace
+ The standard trace masks are given in wxLogTrace()
documentation.
Finally, the @e wxLog::DoLog() function automatically prepends a time stamp
to all the messages. The format of the time stamp may be changed: it can be
/**
Returns @true if the @a mask is one of allowed masks for
- wxLogTrace.
+ wxLogTrace().
See also: AddTraceMask(),
RemoveTraceMask()
*/
/**
Remove the @a mask from the list of allowed masks for
- wxLogTrace.
+ wxLogTrace().
See also: AddTraceMask()
*/
static void RemoveTraceMask(const wxString& mask);
};
+
/**
@class wxLogNull
@wxheader{log.h}
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
call even before the application has been initialized or if it is currently in
some other strange state (for example, about to crash). Under Windows this
function shows a message box using a native dialog instead of
- wxMessageBox (which might be unsafe to call), elsewhere
+ wxMessageBox() (which might be unsafe to call), elsewhere
it simply prints the message to the standard output using the title as prefix.
@param title
@param text
The text to show to the user
- @see wxLogFatalError
+ @see wxLogFatalError()
*/
void wxSafeShowMessage(const wxString& title,
const wxString& text);
/////////////////////////////////////////////////////////////////////////////
// Name: longlong.h
-// Purpose: documentation for wxLongLong class
+// Purpose: interface of wxLongLong
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
If a native (i.e. supported directly by the compiler) 64 bit integer type was
found to exist, @e wxLongLong_t macro will be defined to correspond to it.
Also, in this case only, two additional macros will be defined:
- wxLongLongFmtSpec for printing 64 bit integers
+ wxLongLongFmtSpec() for printing 64 bit integers
using the standard @c printf() function (but see also
wxLongLong::ToString for a more portable solution) and
- wxLL for defining 64 bit integer compile-time constants.
+ wxLL() for defining 64 bit integer compile-time constants.
@library{wxbase}
@category{data}
/**
Assignment operator from unsigned long long. The sign bit will be copied too.
- This function is new since wxWidgets version 2.7.0
+
+ @wxsince{2.7.0}
*/
wxLongLong& operator operator=(const wxULongLong& ll);
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
#endif
@endcode
- @see wxLL
+ @see wxLL()
*/
#endif
@endcode
- @see wxLL, wxLongLong
+ @see wxLL(), wxLongLong
*/
wxLongLong_t wxULL(number);
#endif
@endcode
- @see wxULL, wxLongLong
+ @see wxULL(), wxLongLong
*/
wxLongLong_t wxLL(number);
/////////////////////////////////////////////////////////////////////////////
// Name: math.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// Name: mdi.h
-// Purpose: documentation for wxMDIClientWindow class
+// Purpose: interface of wxMDIClientWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxMDIChildFrame, wxMDIParentFrame, wxFrame
+ @see wxMDIChildFrame, wxMDIParentFrame, wxFrame
*/
class wxMDIClientWindow : public wxWindow
{
};
+
/**
@class wxMDIParentFrame
@wxheader{mdi.h}
@library{wxcore}
@category{managedwnd}
- @seealso
- wxMDIChildFrame, wxMDIClientWindow, wxFrame, wxDialog
+ @see wxMDIChildFrame, wxMDIClientWindow, wxFrame, wxDialog
*/
class wxMDIParentFrame : public wxFrame
{
};
+
/**
@class wxMDIChildFrame
@wxheader{mdi.h}
@library{wxcore}
@category{managedwnd}
- @seealso
- wxMDIClientWindow, wxMDIParentFrame, wxFrame
+ @see wxMDIClientWindow, wxMDIParentFrame, wxFrame
*/
class wxMDIChildFrame : public wxFrame
{
*/
void Restore();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: mediactrl.h
-// Purpose: documentation for wxMediaEvent class
+// Purpose: interface of wxMediaEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxMediaCtrl
@wxheader{mediactrl.h}
@library{wxmedia}
@category{media}
- @seealso
- wxMediaEvent
+ @see wxMediaEvent
*/
class wxMediaCtrl : public wxControl
{
/**
Stops the media.
- See Operation for an overview of how
+ See Operation() for an overview of how
stopping works.
*/
bool Stop();
original size without any extra assistance needed from the user.
*/
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: memory.h
-// Purpose: documentation for wxDebugStreamBuf class
+// Purpose: interface of wxDebugStreamBuf
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- Overview
+ @see Overview()
*/
class wxDebugStreamBuf
{
};
+
/**
@class wxDebugContext
@wxheader{memory.h}
@library{wxbase}
@category{debugging}
- @seealso
- Overview
+ @see Overview()
*/
class wxDebugContext
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: menu.h
-// Purpose: documentation for wxMenuBar class
+// Purpose: interface of wxMenuBar
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{menus}
- @seealso
- wxMenu, @ref overview_eventhandlingoverview
+ @see wxMenu, @ref overview_eventhandlingoverview
*/
class wxMenuBar : public wxWindow
{
};
+
/**
@class wxMenu
@wxheader{menu.h}
@library{wxcore}
@category{menus}
- @seealso
- wxMenuBar, wxWindow::PopupMenu, @ref overview_eventhandlingoverview, @ref
+ @see wxMenuBar, wxWindow::PopupMenu, @ref overview_eventhandlingoverview, @ref
overview_wxfilehistory "wxFileHistory (most recently used files menu)"
*/
class wxMenu : public wxEvtHandler
*/
void UpdateUI(wxEvtHandler* source = NULL) const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: menuitem.h
-// Purpose: documentation for wxMenuItem class
+// Purpose: interface of wxMenuItem
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{menus}
- @seealso
- wxMenuBar, wxMenu
+ @see wxMenuBar, wxMenu
*/
class wxMenuItem : public wxObject
{
*/
void SetTextColour(const wxColour& colour);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: metafile.h
-// Purpose: documentation for wxMetafileDC class
+// Purpose: interface of wxMetafileDC
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{dc}
- @seealso
- wxMetafile, wxDC
+ @see wxMetafile, wxDC
*/
class wxMetafileDC : public wxDC
{
};
+
/**
@class wxMetafile
@wxheader{metafile.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxMetafileDC
+ @see wxMetafileDC
*/
class wxMetafile : public wxObject
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: mimetype.h
-// Purpose: documentation for wxMimeTypesManager class
+// Purpose: interface of wxMimeTypesManager
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{misc}
- @seealso
- wxFileType
+ @see wxFileType
*/
class wxMimeTypesManager
{
};
+
/**
@class wxFileType
@wxheader{mimetype.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxMimeTypesManager
+ @see wxMimeTypesManager
*/
class wxFileType
{
/**
With the first version of this method, if the @true is returned, the
string pointed to by @a command is filled with the command which must be
- executed (see wxExecute) in order to open the file of the
+ executed (see wxExecute()) in order to open the file of the
given type. In this case, the name of the file as well as any other parameters
is retrieved from MessageParameters()
class.
/**
If the function returns @true, the string pointed to by @a command is filled
- with the command which must be executed (see wxExecute) in
+ with the command which must be executed (see wxExecute()) in
order to print the file of the given type. The name of the file is
retrieved from MessageParameters() class.
*/
ever derive from MessageParameters class for a Windows-only program.
*/
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: minifram.h
-// Purpose: documentation for wxMiniFrame class
+// Purpose: interface of wxMiniFrame
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{managedwnd}
- @seealso
- wxMDIParentFrame, wxMDIChildFrame, wxFrame, wxDialog
+ @see wxMDIParentFrame, wxMDIChildFrame, wxFrame, wxDialog
*/
class wxMiniFrame : public wxFrame
{
long style = wxCAPTION | wxRESIZE_BORDER,
const wxString& name = "frame");
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: module.h
-// Purpose: documentation for wxModule class
+// Purpose: interface of wxModule
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
//@{
/**
Call this function from the constructor of the derived class. @a dep must be
- the CLASSINFO of a wxModule-derived class and the
+ the CLASSINFO() of a wxModule-derived class and the
corresponding module will be loaded before and unloaded after
this module.
The second version of this function allows a dependency to be added by
name without access to the class info. This is useful when a module is
declared entirely in a source file and there is no header for the declaration
- of the module needed by CLASSINFO, however errors are
+ of the module needed by CLASSINFO(), however errors are
not detected until run-time, instead of compile-time, then.
Note that circular dependencies are detected and result in a fatal error.
*/
virtual bool OnInit();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: msgdlg.h
-// Purpose: documentation for wxMessageDialog class
+// Purpose: interface of wxMessageDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{cmndlg}
- @seealso
- @ref overview_wxmessagedialogoverview "wxMessageDialog overview"
+ @see @ref overview_wxmessagedialogoverview "wxMessageDialog overview"
*/
class wxMessageDialog : public wxDialog
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: msgqueue.h
-// Purpose: documentation for wxMessageQueue<T> class
+// Purpose: interface of wxMessageQueue<T>
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@nolibrary
@category{FIXME}
- @seealso
- wxThread
+ @see wxThread
*/
class wxMessageQueue<T>
{
*/
wxMessageQueue();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: mstream.h
-// Purpose: documentation for wxMemoryOutputStream class
+// Purpose: interface of wxMemoryOutputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{streams}
- @seealso
- wxStreamBuffer
+ @see wxStreamBuffer
*/
class wxMemoryOutputStream : public wxOutputStream
{
};
+
/**
@class wxMemoryInputStream
@wxheader{mstream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxStreamBuffer, wxMemoryOutputStream
+ @see wxStreamBuffer, wxMemoryOutputStream
*/
class wxMemoryInputStream : public wxInputStream
{
*/
wxStreamBuffer* GetInputStreamBuffer() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: msw/ole/activex.h
-// Purpose: documentation for wxActiveXEvent class
+// Purpose: interface of wxActiveXEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxActiveXContainer
@headerfile ole/activex.h wx/msw/ole/activex.h
@library{wxbase}
@category{FIXME}
- @seealso
- wxActiveXEvent
+ @see wxActiveXEvent
*/
class wxActiveXContainer : public wxControl
{
*/
wxActiveXContainer(wxWindow* parent, REFIID iid, IUnknown* pUnk);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: msw/ole/automtn.h
-// Purpose: documentation for wxAutomationObject class
+// Purpose: interface of wxAutomationObject
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{misc}
- @seealso
- wxVariant
+ @see wxVariant
*/
class wxAutomationObject : public wxObject
{
*/
void SetDispatchPtr(WXIDISPATCH* dispatchPtr);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: msw/registry.h
-// Purpose: documentation for wxRegKey class
+// Purpose: interface of wxRegKey
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
const wxMemoryBuffer& buf);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: notebook.h
-// Purpose: documentation for wxNotebookEvent class
+// Purpose: interface of wxNotebookEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{events}
- @seealso
- wxNotebook
+ @see wxNotebook
*/
class wxNotebookEvent : public wxNotifyEvent
{
};
+
/**
@class wxNotebook
@wxheader{notebook.h}
@library{wxcore}
@category{miscwnd}
- @seealso
- wxBookCtrl, wxNotebookEvent, wxImageList, @ref overview_samplenotebook
+ @see wxBookCtrl(), wxNotebookEvent, wxImageList, @ref overview_samplenotebook
"notebook sample"
*/
class wxNotebook : public wxBookCtrl overview
*/
int SetSelection(size_t page);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: notifmsg.h
-// Purpose: documentation for wxNotificationMessage class
+// Purpose: interface of wxNotificationMessage
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
bool Show(int timeout = Timeout_Auto);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: numdlg.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// Name: object.h
-// Purpose: documentation for wxObjectRefData class
+// Purpose: interface of wxObjectRefData
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxObject, wxObjectDataPtrT, @ref overview_trefcount "Reference counting"
+ @see wxObject, wxObjectDataPtrT(), @ref overview_trefcount "Reference counting"
*/
class wxObjectRefData
{
};
+
/**
@class wxObject
@wxheader{object.h}
@library{wxbase}
@category{rtti}
- @seealso
- wxClassInfo, @ref overview_debuggingoverview, wxObjectRefData
+ @see wxClassInfo, @ref overview_debuggingoverview, wxObjectRefData
*/
class wxObject
{
};
+
/**
@class wxClassInfo
@wxheader{object.h}
@library{wxbase}
@category{rtti}
- @seealso
- Overview, wxObject
+ @see Overview(), wxObject
*/
class wxClassInfo
{
};
+
/**
@class wxObjectDataPtrT
@wxheader{object.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxObject, wxObjectRefData, @ref overview_trefcount "Reference counting"
+ @see wxObject, wxObjectRefData, @ref overview_trefcount "Reference counting"
*/
class wxObjectDataPtr<T>
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
Same as @c reinterpret_castT(x) if the compiler supports reinterpret cast or
@c (T)x for old compilers.
- @see wx_const_cast, wx_static_cast
+ @see wx_const_cast(), wx_static_cast()
*/
T wx_reinterpret_cast();
This macro expands into @c const_castclassname *(ptr) if the compiler
supports @e const_cast or into an old, C-style cast, otherwise.
- @see wx_const_cast, wxDynamicCast, wxStaticCast
+ @see wx_const_cast(), wxDynamicCast(), wxStaticCast()
*/
classname* wxConstCast();
tests whether @c this pointer is non-@NULL which is always @true), so
this macro should be used to avoid them.
- @see wxDynamicCast
+ @see wxDynamicCast()
*/
classname* wxDynamicCastThis();
system and also declare that the objects of this class should be dynamically
creatable from run-time type information. Notice that this implies that the
class should have a default constructor, if this is not the case consider using
- DECLARE_CLASS.
+ DECLARE_CLASS().
Example:
@code
/**
Same as @c const_castT(x) if the compiler supports const cast or
- @c (T)x for old compilers. Unlike wxConstCast,
+ @c (T)x for old compilers. Unlike wxConstCast(),
the cast it to the type @e T and not to @c T * and also the order of
arguments is the same as for the standard cast.
- @see wx_reinterpret_cast, wx_static_cast
+ @see wx_reinterpret_cast(), wx_static_cast()
*/
T wx_const_cast();
}
@endcode
- @see @ref overview_runtimeclassoverview "RTTI overview", wxDynamicCastThis,
- wxConstCast, wxStaticCast
+ @see @ref overview_runtimeclassoverview "RTTI overview", wxDynamicCastThis(),
+ wxConstCast(), wxStaticCast()
*/
classname* wxDynamicCast();
result if @c wxDynamicCast(ptr, classname) == @NULL) and then returns the
result of executing an equivalent of @c static_castclassname *(ptr).
- @see wx_static_cast, wxDynamicCast, wxConstCast
+ @see wx_static_cast(), wxDynamicCast(), wxConstCast()
*/
classname* wxStaticCast();
/**
Same as @c static_castT(x) if the compiler supports static cast or
- @c (T)x for old compilers. Unlike wxStaticCast,
+ @c (T)x for old compilers. Unlike wxStaticCast(),
there are no checks being done and the meaning of the macro arguments is exactly
the same as for the standard static cast, i.e. @e T is the full type name and
star is not appended to it.
- @see wx_const_cast, wx_reinterpret_cast, wx_truncate_cast
+ @see wx_const_cast(), wx_reinterpret_cast(), wx_truncate_cast()
*/
T wx_static_cast();
/////////////////////////////////////////////////////////////////////////////
// Name: odcombo.h
-// Purpose: documentation for wxOwnerDrawnComboBox class
+// Purpose: interface of wxOwnerDrawnComboBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{ownerdrawncombobox.png}
- @seealso
- wxComboCtrl, wxComboBox, wxVListBox, wxCommandEvent
+ @see wxComboCtrl, wxComboBox, wxVListBox, wxCommandEvent
*/
class wxOwnerDrawnComboBox : public wxComboCtrl
{
*/
wxCoord OnMeasureItemWidth(size_t item) const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: palette.h
-// Purpose: documentation for wxPalette class
+// Purpose: interface of wxPalette
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{gdi}
@stdobjects
- Objects:
- wxNullPalette
+ ::Objects:, ::wxNullPalette,
- @seealso
- wxDC::SetPalette, wxBitmap
+ @see wxDC::SetPalette, wxBitmap
*/
class wxPalette : public wxGDIObject
{
*/
wxPalette operator =(const wxPalette& palette);
};
+
+
+/**
+ FIXME
+*/
+wxPalette Objects:
+;
+
+/**
+ FIXME
+*/
+wxPalette wxNullPalette;
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: panel.h
-// Purpose: documentation for wxPanel class
+// Purpose: interface of wxPanel
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{miscwnd}
- @seealso
- wxDialog
+ @see wxDialog
*/
class wxPanel : public wxWindow
{
*/
virtual void SetFocusIgnoringChildren();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: pen.h
-// Purpose: documentation for wxPen class
+// Purpose: interface of wxPen
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{gdi}
@stdobjects
- Objects:
- wxNullPen
- Pointers:
- wxRED_PEN
+ ::Objects:, ::wxNullPen, ::Pointers:, ::wxRED_PEN, ::wxCYAN_PEN, ::wxGREEN_PEN,
+ ::wxBLACK_PEN, ::wxWHITE_PEN, ::wxTRANSPARENT_PEN, ::wxBLACK_DASHED_PEN, ::wxGREY_PEN, ::wxMEDIUM_GREY_PEN, ::wxLIGHT_GREY_PEN,
- wxCYAN_PEN
-
- wxGREEN_PEN
-
- wxBLACK_PEN
-
- wxWHITE_PEN
-
- wxTRANSPARENT_PEN
-
- wxBLACK_DASHED_PEN
-
- wxGREY_PEN
-
- wxMEDIUM_GREY_PEN
-
- wxLIGHT_GREY_PEN
-
- @seealso
- wxPenList, wxDC, wxDC::SetPen
+ @see wxPenList, wxDC, wxDC::SetPen
*/
class wxPen : public wxGDIObject
{
*/
bool operator ==(const wxPen& pen);
};
+
+
+/**
+ FIXME
+*/
+wxPen Objects:
+;
+
+/**
+ FIXME
+*/
+wxPen wxNullPen;
+
+/**
+ FIXME
+*/
+wxPen Pointers:
+;
+
+/**
+ FIXME
+*/
+wxPen wxRED_PEN;
+
+/**
+ FIXME
+*/
+wxPen wxCYAN_PEN;
+
+/**
+ FIXME
+*/
+wxPen wxGREEN_PEN;
+
+/**
+ FIXME
+*/
+wxPen wxBLACK_PEN;
+
+/**
+ FIXME
+*/
+wxPen wxWHITE_PEN;
+
+/**
+ FIXME
+*/
+wxPen wxTRANSPARENT_PEN;
+
+/**
+ FIXME
+*/
+wxPen wxBLACK_DASHED_PEN;
+
+/**
+ FIXME
+*/
+wxPen wxGREY_PEN;
+
+/**
+ FIXME
+*/
+wxPen wxMEDIUM_GREY_PEN;
+
+/**
+ FIXME
+*/
+wxPen wxLIGHT_GREY_PEN;
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: pickerbase.h
-// Purpose: documentation for wxPickerBase class
+// Purpose: interface of wxPickerBase
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxColourPickerCtrl
+ @see wxColourPickerCtrl
*/
class wxPickerBase : public wxControl
{
*/
void SetTextCtrlProportion(int prop);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: platform.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// 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.
*/
#define bool wxCHECK_VERSION_FULL(major, minor, release, subrel) /* implementation is private */
/////////////////////////////////////////////////////////////////////////////
// Name: platinfo.h
-// Purpose: documentation for wxPlatformInfo class
+// Purpose: interface of wxPlatformInfo
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxGetOSVersion, wxIsPlatformLittleEndian, wxIsPlatform64Bit, wxAppTraits
+ @see wxGetOSVersion(), wxIsPlatformLittleEndian(), wxIsPlatform64Bit(),
+ wxAppTraits
*/
class wxPlatformInfo : public wxObject
{
/**
Returns the run-time major version of the OS associated with this
wxPlatformInfo instance.
- See wxGetOsVersion for more info.
+ See wxGetOsVersion() for more info.
@see CheckOSVersion()
*/
/**
Returns the run-time minor version of the OS associated with this
wxPlatformInfo instance.
- See wxGetOsVersion for more info.
+ See wxGetOsVersion() for more info.
@see CheckOSVersion()
*/
*/
bool operator==(const wxPlatformInfo& t) const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: position.h
-// Purpose: documentation for wxPosition class
+// Purpose: interface of wxPosition
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxPoint, wxSize
+ @see wxPoint, wxSize
*/
class wxPosition
{
*/
void SetRow(int row);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: power.h
-// Purpose: documentation for wxPowerEvent class
+// Purpose: interface of wxPowerEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxGetPowerType, wxGetBatteryState
+ @see wxGetPowerType(), wxGetBatteryState()
*/
class wxPowerEvent : public wxEvent
{
*/
void Veto();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: print.h
-// Purpose: documentation for wxPreviewControlBar class
+// Purpose: interface of wxPreviewControlBar
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{printing}
- @seealso
- wxPreviewFrame, wxPreviewCanvas, wxPrintPreview
+ @see wxPreviewFrame, wxPreviewCanvas, wxPrintPreview
*/
class wxPreviewControlBar : public wxPanel
{
};
+
/**
@class wxPreviewCanvas
@wxheader{print.h}
@library{wxbase}
@category{printing}
- @seealso
- wxPreviewFrame, wxPreviewControlBar, wxPrintPreview
+ @see wxPreviewFrame, wxPreviewControlBar, wxPrintPreview
*/
class wxPreviewCanvas : public wxScrolledWindow
{
};
+
/**
@class wxPreviewFrame
@wxheader{print.h}
@library{wxbase}
@category{printing}
- @seealso
- wxPreviewCanvas, wxPreviewControlBar, wxPrintPreview
+ @see wxPreviewCanvas, wxPreviewControlBar, wxPrintPreview
*/
class wxPreviewFrame : public wxFrame
{
};
+
/**
@class wxPrintPreview
@wxheader{print.h}
@library{wxbase}
@category{printing}
- @seealso
- @ref overview_printingoverview "Printing framework overview", wxPrinterDC,
+ @see @ref overview_printingoverview "Printing framework overview", wxPrinterDC,
wxPrintDialog, wxPrintout, wxPrinter, wxPreviewCanvas, wxPreviewControlBar, wxPreviewFrame.
*/
class wxPrintPreview : public wxObject
};
+
/**
@class wxPrinter
@wxheader{print.h}
@library{wxbase}
@category{printing}
- @seealso
- @ref overview_printingoverview "Printing framework overview", wxPrinterDC,
+ @see @ref overview_printingoverview "Printing framework overview", wxPrinterDC,
wxPrintDialog, wxPrintout, wxPrintPreview.
*/
class wxPrinter : public wxObject
};
+
/**
@class wxPrintout
@wxheader{print.h}
@library{wxbase}
@category{printing}
- @seealso
- @ref overview_printingoverview "Printing framework overview", wxPrinterDC,
+ @see @ref overview_printingoverview "Printing framework overview", wxPrinterDC,
wxPrintDialog, wxPageSetupDialog, wxPrinter, wxPrintPreview
*/
class wxPrintout : public wxObject
*/
void SetLogicalOrigin(wxCoord x, wxCoord y);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: printdlg.h
-// Purpose: documentation for wxPrintDialog class
+// Purpose: interface of wxPrintDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{printing}
- @seealso
- @ref overview_printingoverview "Printing framework overview", @ref
+ @see @ref overview_printingoverview "Printing framework overview", @ref
overview_wxprintdialogoverview "wxPrintDialog Overview"
*/
class wxPrintDialog : public wxDialog
};
+
/**
@class wxPageSetupDialog
@wxheader{printdlg.h}
@library{wxcore}
@category{printing}
- @seealso
- @ref overview_printingoverview "Printing framework overview", wxPrintDialog,
- wxPageSetupDialogData
+ @see @ref overview_printingoverview "Printing framework overview",
+ wxPrintDialog, wxPageSetupDialogData
*/
class wxPageSetupDialog : public wxDialog
{
*/
int ShowModal();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: process.h
-// Purpose: documentation for wxProcess class
+// Purpose: interface of wxProcess
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@wxheader{process.h}
The objects of this class are used in conjunction with the
- wxExecute function. When a wxProcess object is passed to
+ wxExecute() function. When a wxProcess object is passed to
wxExecute(), its wxProcess::OnTerminate virtual method
is called when the process terminates. This allows the program to be
(asynchronously) notified about the process termination and also retrieve its
wxProcess also supports IO redirection of the child process. For this, you have
to call its wxProcess::Redirect method before passing it to
- wxExecute. If the child process was launched successfully,
+ wxExecute(). If the child process was launched successfully,
wxProcess::GetInputStream,
wxProcess::GetOutputStream and
wxProcess::GetErrorStream can then be used to retrieve
@library{wxbase}
@category{appmanagement}
- @seealso
- wxExecute, @ref overview_sampleexec "exec sample"
+ @see wxExecute(), @ref overview_sampleexec "exec sample"
*/
class wxProcess : public wxEvtHandler
{
to work you should have created the process passing wxEXEC_MAKE_GROUP_LEADER.
Returns the element of @c wxKillError enum:
- @see Exists(), wxKill, @ref overview_sampleexec "Exec sample"
+ @see Exists(), wxKill(), @ref overview_sampleexec "Exec sample"
*/
static wxKillError Kill(int pid, wxSignal signal = wxSIGNONE,
int flags = wxKILL_NOCHILDREN);
@returns A pointer to new wxProcess object or @NULL on error.
- @see wxExecute
+ @see wxExecute()
*/
static wxProcess* Open(const wxString& cmd,
int flags = wxEXEC_ASYNC);
};
+
/**
@class wxProcessEvent
@wxheader{process.h}
@library{wxbase}
@category{events}
- @seealso
- wxProcess, @ref overview_eventhandlingoverview
+ @see wxProcess, @ref overview_eventhandlingoverview
*/
class wxProcessEvent : public wxEvent
{
*/
int GetPid() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: progdlg.h
-// Purpose: documentation for wxProgressDialog class
+// Purpose: interface of wxProgressDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
virtual bool Update(int value, const wxString& newmsg = "",
bool* skip = NULL);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: propdlg.h
-// Purpose: documentation for wxPropertySheetDialog class
+// Purpose: interface of wxPropertySheetDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
void SetSheetStyle(long style);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: protocol/ftp.h
-// Purpose: documentation for wxFTP class
+// Purpose: interface of wxFTP
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxnet}
@category{net}
- @seealso
- wxSocketBase
+ @see wxSocketBase
*/
class wxFTP : public wxProtocol
{
*/
void SetUser(const wxString& user);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: protocol/http.h
-// Purpose: documentation for wxHTTP class
+// Purpose: interface of wxHTTP
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxnet}
@category{net}
- @seealso
- wxSocketBase, wxURL
+ @see wxSocketBase, wxURL
*/
class wxHTTP : public wxProtocol
{
*/
void SetHeader(const wxString& header, const wxString& h_data);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: protocol/protocol.h
-// Purpose: documentation for wxProtocol class
+// Purpose: interface of wxProtocol
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxnet}
@category{FIXME}
- @seealso
- wxSocketBase, wxURL
+ @see wxSocketBase, wxURL
*/
class wxProtocol : public wxSocketClient
{
*/
void SetUser(const wxString& user);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: ptr_scpd.h
-// Purpose: documentation for wxScopedPtr class
+// Purpose: interface of wxScopedPtr
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
use macros instead.
Since wxWidgets 2.9.0 there is also a templated version of this class
- with the same name. See wxScopedPtrT.
+ with the same name. See wxScopedPtrT().
A smart pointer holds a pointer to an object. The memory used by the object is
deleted when the smart pointer goes out of scope. This class is different from
@library{wxbase}
@category{FIXME}
- @seealso
- wxScopedArray
+ @see wxScopedArray
*/
class wxScopedPtr
{
};
+
/**
@class wxScopedArray
@wxheader{ptr_scpd.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxScopedPtr
+ @see wxScopedPtr
*/
class wxScopedArray
{
};
+
/**
@class wxScopedTiedPtr
@wxheader{ptr_scpd.h}
};
+
/**
@class wxScopedPtrT
@wxheader{ptr_scpd.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxSharedPtr, wxWeakRef
+ @see wxSharedPtr, wxWeakRef
*/
class wxScopedPtr<T>
{
*/
void swap(wxScopedPtr<T>& ot);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: ptr_shrd.h
-// Purpose: documentation for wxSharedPtr<T> class
+// Purpose: interface of wxSharedPtr<T>
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
A smart pointer with non-intrusive reference counting. It is modeled
after @b boost::shared_ptr and can be used with STL containers
- and wxVector - unlike @b std::auto_ptr
- and wxScopedPtr.
+ and wxVector() - unlike @b std::auto_ptr
+ and wxScopedPtr().
@library{wxbase}
@category{FIXME}
- @seealso
- wxScopedPtr, wxWeakRef, wxObjectDataPtr
+ @see wxScopedPtr, wxWeakRef, wxObjectDataPtr
*/
class wxSharedPtr<T>
{
*/
long use_count() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: quantize.h
-// Purpose: documentation for wxQuantize class
+// Purpose: interface of wxQuantize
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE|wxQUANTIZE_RETURN_8BIT_DATA);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: radiobox.h
-// Purpose: documentation for wxRadioBox class
+// Purpose: interface of wxRadioBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{radiobox.png}
- @seealso
- @ref overview_eventhandlingoverview, wxRadioButton, wxCheckBox
+ @see @ref overview_eventhandlingoverview, wxRadioButton, wxCheckBox
*/
class wxRadioBox : public wxControlWithItems
{
*/
void SetStringSelection(const wxString& string);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: radiobut.h
-// Purpose: documentation for wxRadioButton class
+// Purpose: interface of wxRadioButton
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{radiobutton.png}
- @seealso
- @ref overview_eventhandlingoverview, wxRadioBox, wxCheckBox
+ @see @ref overview_eventhandlingoverview, wxRadioBox, wxCheckBox
*/
class wxRadioButton : public wxControl
{
*/
void SetValue(const bool value);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: recguard.h
-// Purpose: documentation for wxRecursionGuardFlag class
+// Purpose: interface of wxRecursionGuardFlag
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxRecursionGuard
@wxheader{recguard.h}
*/
bool IsInside() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: regex.h
-// Purpose: documentation for wxRegEx class
+// Purpose: interface of wxRegEx
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
Regular expressions, as defined by POSIX, come in two flavours: @e extended
and @e basic. The builtin library also adds a third flavour
- of expression advanced, which is not available
+ of expression advanced(), which is not available
when using the system library.
Unicode is fully supported only when using the builtin library.
@library{wxbase}
@category{data}
- @seealso
- wxRegEx::ReplaceFirst
+ @see wxRegEx::ReplaceFirst
*/
class wxRegEx
{
*/
int ReplaceFirst(wxString* text, const wxString& replacement) const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: region.h
-// Purpose: documentation for wxRegionIterator class
+// Purpose: interface of wxRegionIterator
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxPaintEvent
+ @see wxPaintEvent
*/
class wxRegionIterator : public wxObject
{
};
+
/**
@class wxRegion
@wxheader{region.h}
@library{wxcore}
@category{data}
- @seealso
- wxRegionIterator
+ @see wxRegionIterator
*/
class wxRegion : public wxGDIObject
{
*/
void operator =(const wxRegion& region);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: renderer.h
-// Purpose: documentation for wxSplitterRenderParams class
+// Purpose: interface of wxSplitterRenderParams
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxDelegateRendererNative
@wxheader{renderer.h}
};
+
/**
@class wxRendererNative
@wxheader{renderer.h}
};
+
/**
@class wxRendererVersion
@wxheader{renderer.h}
each time a new virtual method is added and so, at least for the compilers
using a common C++ object model, the calling program is compatible with any
renderer which has the age greater or equal to its age. This verification is
- done by IsCompatible method.
+ done by IsCompatible() method.
@library{wxbase}
@category{FIXME}
The version component.
*/
};
+
@library{wxrichtext}
@category{richtext}
- @seealso
- wxTextAttr, wxRichTextCtrl
+ @see wxTextAttr, wxRichTextCtrl
*/
class wxRichTextBuffer
{
};
+
/**
@class wxRichTextFileHandler
@headerfile richtextbuffer.h wx/richtext/richtextbuffer.h
};
+
/**
@class wxRichTextRange
@headerfile richtextbuffer.h wx/richtext/richtextbuffer.h
*/
bool operator==(const wxRichTextRange& range) const;
};
+
};
+
/**
@class wxRichTextCtrl
@headerfile richtextctrl.h wx/richtext/richtextctrl.h
*/
long XYToPosition(long x, long y) const;
};
+
};
+
/**
@class wxRichTextFormattingDialog
@headerfile richtextformatdlg.h wx/richtext/richtextformatdlg.h
*/
bool UpdateDisplay();
};
+
*/
void SetTemporaryImageLocations(const wxArrayString& locations);
};
+
};
+
/**
@class wxRichTextPrintout
@headerfile richtextprint.h wx/richtext/richtextprint.h
};
+
/**
@class wxRichTextPrinting
@headerfile richtextprint.h wx/richtext/richtextprint.h
*/
void SetTitle(const wxString& title);
};
+
*/
int GetFlags() const;
};
+
};
+
/**
@class wxRichTextStyleDefinition
@headerfile richtextstyles.h wx/richtext/richtextstyles.h
};
+
/**
@class wxRichTextParagraphStyleDefinition
@headerfile richtextstyles.h wx/richtext/richtextstyles.h
};
+
/**
@class wxRichTextStyleListBox
@headerfile richtextstyles.h wx/richtext/richtextstyles.h
@library{wxrichtext}
@category{richtext}
- @seealso
- wxRichTextStyleComboCtrl, @ref overview_wxrichtextctrloverview "wxRichTextCtrl
- overview"
+ @see wxRichTextStyleComboCtrl, @ref overview_wxrichtextctrloverview
+ "wxRichTextCtrl overview"
*/
class wxRichTextStyleListBox : public wxHtmlListBox
{
};
+
/**
@class wxRichTextStyleComboCtrl
@headerfile richtextstyles.h wx/richtext/richtextstyles.h
@library{wxrichtext}
@category{richtext}
- @seealso
- wxRichTextStyleListBox, @ref overview_wxrichtextctrloverview "wxRichTextCtrl
- overview"
+ @see wxRichTextStyleListBox, @ref overview_wxrichtextctrloverview
+ "wxRichTextCtrl overview"
*/
class wxRichTextStyleComboCtrl : public wxComboCtrl
{
};
+
/**
@class wxRichTextCharacterStyleDefinition
@headerfile richtextstyles.h wx/richtext/richtextstyles.h
};
+
/**
@class wxRichTextListStyleDefinition
@headerfile richtextstyles.h wx/richtext/richtextstyles.h
};
+
/**
@class wxRichTextStyleSheet
@headerfile richtextstyles.h wx/richtext/richtextstyles.h
*/
void SetName(const wxString& name);
};
+
*/
bool UseNormalFont() const;
};
+
*/
bool ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: sashwin.h
-// Purpose: documentation for wxSashWindow class
+// Purpose: interface of wxSashWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxadv}
@category{miscwnd}
- @seealso
- wxSashEvent, wxSashLayoutWindow, @ref overview_eventhandlingoverview
+ @see wxSashEvent, wxSashLayoutWindow, @ref overview_eventhandlingoverview
*/
class wxSashWindow : public wxWindow
{
};
+
/**
@class wxSashEvent
@wxheader{sashwin.h}
@library{wxadv}
@category{FIXME}
- @seealso
- wxSashWindow, @ref overview_eventhandlingoverview
+ @see wxSashWindow, @ref overview_eventhandlingoverview
*/
class wxSashEvent : public wxCommandEvent
{
*/
wxSashEdgePosition GetEdge() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: sckipc.h
-// Purpose: documentation for wxTCPServer class
+// Purpose: interface of wxTCPServer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxnet}
@category{FIXME}
- @seealso
- wxTCPClient, wxTCPConnection, @ref overview_ipcoverview "IPC overview"
+ @see wxTCPClient, wxTCPConnection, @ref overview_ipcoverview "IPC overview"
*/
class wxTCPServer : public wxObject
{
};
+
/**
@class wxTCPClient
@wxheader{sckipc.h}
@library{wxnet}
@category{FIXME}
- @seealso
- wxTCPServer, wxTCPConnection, @ref overview_ipcoverview "Interprocess
+ @see wxTCPServer, wxTCPConnection, @ref overview_ipcoverview "Interprocess
communications overview"
*/
class wxTCPClient : public wxObject
};
+
/**
@class wxTCPConnection
@wxheader{sckipc.h}
@library{wxnet}
@category{FIXME}
- @seealso
- wxTCPClient, wxTCPServer, @ref overview_ipcoverview "Interprocess
+ @see wxTCPClient, wxTCPServer, @ref overview_ipcoverview "Interprocess
communications overview"
*/
class wxTCPConnection : public wxObject
*/
bool StopAdvise(const wxString& item);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: sckstrm.h
-// Purpose: documentation for wxSocketOutputStream class
+// Purpose: interface of wxSocketOutputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxnet}
@category{streams}
- @seealso
- wxSocketBase
+ @see wxSocketBase
*/
class wxSocketOutputStream : public wxOutputStream
{
};
+
/**
@class wxSocketInputStream
@wxheader{sckstrm.h}
@library{wxnet}
@category{streams}
- @seealso
- wxSocketBase
+ @see wxSocketBase
*/
class wxSocketInputStream : public wxInputStream
{
*/
wxSocketInputStream(wxSocketBase& s);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: scopeguard.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// 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.
*/
wxON_BLOCK_EXIT_OBJ0(obj, method);
published in December 2000 issue of C/C++ Users Journal for more
details.
- @see wxON_BLOCK_EXIT_OBJ
+ @see wxON_BLOCK_EXIT_OBJ()
*/
wxON_BLOCK_EXIT0(func);
wxON_BLOCK_EXIT1(func, p1);
/////////////////////////////////////////////////////////////////////////////
// Name: scrolbar.h
-// Purpose: documentation for wxScrollBar class
+// Purpose: interface of wxScrollBar
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{scrollbar.png}
- @seealso
- @ref overview_scrollingoverview "Scrolling overview", @ref
+ @see @ref overview_scrollingoverview "Scrolling overview", @ref
overview_eventhandlingoverview, wxScrolledWindow
*/
class wxScrollBar : public wxControl
*/
void SetThumbPosition(int viewStart);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: scrolwin.h
-// Purpose: documentation for wxScrolledWindow class
+// Purpose: interface of wxScrolledWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{miscwnd}
- @seealso
- wxScrollBar, wxClientDC, wxPaintDC, wxVScrolledWindow
+ @see wxScrollBar, wxClientDC, wxPaintDC, wxVScrolledWindow
*/
class wxScrolledWindow : public wxPanel
{
*/
void SetTargetWindow(wxWindow* window);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: settings.h
-// Purpose: documentation for wxSystemSettings class
+// Purpose: interface of wxSystemSettings
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{misc}
- @seealso
- wxFont, wxColour
+ @see wxFont, wxColour
*/
class wxSystemSettings : public wxObject
{
*/
static wxSystemScreenType GetScreenType();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: sizer.h
-// Purpose: documentation for wxStdDialogButtonSizer class
+// Purpose: interface of wxStdDialogButtonSizer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxSizer, @ref overview_sizeroverview "Sizer overview",
+ @see wxSizer, @ref overview_sizeroverview "Sizer overview",
wxDialog::CreateButtonSizer
*/
class wxStdDialogButtonSizer : public wxBoxSizer
};
+
/**
@class wxSizerItem
@wxheader{sizer.h}
};
+
/**
@class wxSizerFlags
@wxheader{sizer.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxSizer
+ @see wxSizer
*/
class wxSizerFlags
{
};
+
/**
@class wxNotebookSizer
@wxheader{sizer.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxSizer, wxNotebook, @ref overview_sizeroverview "Sizer overview"
+ @see wxSizer, wxNotebook, @ref overview_sizeroverview "Sizer overview"
*/
class wxNotebookSizer : public wxSizer
{
};
+
/**
@class wxFlexGridSizer
@wxheader{sizer.h}
@library{wxcore}
@category{winlayout}
- @seealso
- wxSizer, @ref overview_sizeroverview "Sizer overview"
+ @see wxSizer, @ref overview_sizeroverview "Sizer overview"
*/
class wxFlexGridSizer : public wxGridSizer
{
Specifies that column @a idx (starting from zero) should be grown if
there is extra space available to the sizer.
The @a proportion parameter has the same meaning as the stretch factor for
- the sizers except that if all proportions are 0,
+ the sizers() except that if all proportions are 0,
then all columns are resized equally (instead of not being resized at all).
*/
void AddGrowableCol(size_t idx, int proportion = 0);
};
+
/**
@class wxSizer
@wxheader{sizer.h}
@library{wxcore}
@category{winlayout}
- @seealso
- @ref overview_sizeroverview "Sizer overview"
+ @see @ref overview_sizeroverview "Sizer overview"
*/
class wxSizer : public wxObject
{
};
+
/**
@class wxGridSizer
@wxheader{sizer.h}
@library{wxcore}
@category{winlayout}
- @seealso
- wxSizer, @ref overview_sizeroverview "Sizer overview"
+ @see wxSizer, @ref overview_sizeroverview "Sizer overview"
*/
class wxGridSizer : public wxSizer
{
};
+
/**
@class wxStaticBoxSizer
@wxheader{sizer.h}
@library{wxcore}
@category{winlayout}
- @seealso
- wxSizer, wxStaticBox, wxBoxSizer, @ref overview_sizeroverview "Sizer overview"
+ @see wxSizer, wxStaticBox, wxBoxSizer, @ref overview_sizeroverview "Sizer
+ overview"
*/
class wxStaticBoxSizer : public wxBoxSizer
{
};
+
/**
@class wxBoxSizer
@wxheader{sizer.h}
@library{wxcore}
@category{winlayout}
- @seealso
- wxSizer, @ref overview_sizeroverview "Sizer overview"
+ @see wxSizer, @ref overview_sizeroverview "Sizer overview"
*/
class wxBoxSizer : public wxSizer
{
*/
void RecalcSizes();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: slider.h
-// Purpose: documentation for wxSlider class
+// Purpose: interface of wxSlider
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{slider.png}
- @seealso
- @ref overview_eventhandlingoverview, wxScrollBar
+ @see @ref overview_eventhandlingoverview, wxScrollBar
*/
class wxSlider : public wxControl
{
*/
void SetValue(int value);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: snglinst.h
-// Purpose: documentation for wxSingleInstanceChecker class
+// Purpose: interface of wxSingleInstanceChecker
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
}
@endcode
- Note using wxGetUserId to construct the name: this
+ Note using wxGetUserId() to construct the name: this
allows different user to run the application concurrently which is usually the
intended goal. If you don't use the user name in the wxSingleInstanceChecker
name, only one user would be able to run the application at a time.
*/
bool IsAnotherRunning() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: socket.h
-// Purpose: documentation for wxIPV4address class
+// Purpose: interface of wxIPV4address
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxSocketServer
@wxheader{socket.h}
@library{wxnet}
@category{net}
- @seealso
- wxSocketServer::WaitForAccept, wxSocketBase::SetNotify, wxSocketBase::Notify,
- wxSocketServer::AcceptWith
+ @see wxSocketServer::WaitForAccept, wxSocketBase::SetNotify,
+ wxSocketBase::Notify, wxSocketServer::AcceptWith
*/
class wxSocketServer : public wxSocketBase
{
};
+
/**
@class wxIPaddress
@wxheader{socket.h}
};
+
/**
@class wxSocketClient
@wxheader{socket.h}
@library{wxnet}
@category{net}
- @seealso
- wxSocketClient::WaitOnConnect, wxSocketBase::SetNotify, wxSocketBase::Notify
+ @see wxSocketClient::WaitOnConnect, wxSocketBase::SetNotify,
+ wxSocketBase::Notify
*/
class wxSocketClient : public wxSocketBase
{
};
+
/**
@class wxSockAddress
@wxheader{socket.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxSocketBase, wxIPaddress, wxIPV4address
+ @see wxSocketBase, wxIPaddress, wxIPV4address
*/
class wxSockAddress : public wxObject
{
};
+
/**
@class wxSocketEvent
@wxheader{socket.h}
@library{wxnet}
@category{net}
- @seealso
- wxSocketBase, wxSocketClient, wxSocketServer
+ @see wxSocketBase, wxSocketClient, wxSocketServer
*/
class wxSocketEvent : public wxEvent
{
};
+
/**
@class wxSocketBase
@wxheader{socket.h}
@library{wxnet}
@category{net}
- @seealso
- wxSocketEvent, wxSocketClient, wxSocketServer, @ref overview_samplesockets
+ @see wxSocketEvent, wxSocketClient, wxSocketServer, @ref overview_samplesockets
"Sockets sample"
*/
class wxSocketBase : public wxObject
};
+
/**
@class wxDatagramSocket
@wxheader{socket.h}
@library{wxnet}
@category{FIXME}
- @seealso
- wxSocketBase::Error, wxSocketBase::LastError, wxSocketBase::LastCount,
+ @see wxSocketBase::Error, wxSocketBase::LastError, wxSocketBase::LastCount,
wxSocketBase::SetFlags,
*/
class wxDatagramSocket : public wxSocketBase
const void* buffer,
wxUint32 nbytes);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: sound.h
-// Purpose: documentation for wxSound class
+// Purpose: interface of wxSound
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
static void Stop();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: spinbutt.h
-// Purpose: documentation for wxSpinEvent class
+// Purpose: interface of wxSpinEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{events}
- @seealso
- wxSpinButton and wxSpinCtrl
+ @see wxSpinButton and wxSpinCtrl
*/
class wxSpinEvent : public wxNotifyEvent
{
};
+
/**
@class wxSpinButton
@wxheader{spinbutt.h}
@category{ctrl}
@appearance{spinbutton.png}
- @seealso
- wxSpinCtrl
+ @see wxSpinCtrl
*/
class wxSpinButton : public wxControl
{
*/
void SetValue(int value);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: spinctrl.h
-// Purpose: documentation for wxSpinCtrl class
+// Purpose: interface of wxSpinCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{spinctrl.png}
- @seealso
- @ref overview_eventhandlingoverview, wxSpinButton, wxControl
+ @see @ref overview_eventhandlingoverview, wxSpinButton, wxControl
*/
class wxSpinCtrl : public wxControl
{
void SetValue(int value);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: splash.h
-// Purpose: documentation for wxSplashScreen class
+// Purpose: interface of wxSplashScreen
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
void OnCloseWindow(wxCloseEvent& event);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: splitter.h
-// Purpose: documentation for wxSplitterWindow class
+// Purpose: interface of wxSplitterWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{miscwnd}
- @seealso
- wxSplitterEvent
+ @see wxSplitterEvent
*/
class wxSplitterWindow : public wxWindow
{
};
+
/**
@class wxSplitterEvent
@wxheader{splitter.h}
@library{wxcore}
@category{events}
- @seealso
- wxSplitterWindow, @ref overview_eventhandlingoverview
+ @see wxSplitterWindow, @ref overview_eventhandlingoverview
*/
class wxSplitterEvent : public wxNotifyEvent
{
*/
void SetSashPosition(int pos);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: srchctrl.h
-// Purpose: documentation for wxSearchCtrl class
+// Purpose: interface of wxSearchCtrl
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxTextCtrl::Create, wxValidator
+ @see wxTextCtrl::Create, wxValidator
*/
class wxSearchCtrl : public wxTextCtrl
{
*/
virtual void ShowSearchButton(bool show);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: sstream.h
-// Purpose: documentation for wxStringInputStream class
+// Purpose: interface of wxStringInputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxStringOutputStream
@wxheader{sstream.h}
*/
const wxString GetString() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: stackwalk.h
-// Purpose: documentation for wxStackWalker class
+// Purpose: interface of wxStackWalker
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxStackFrame
+ @see wxStackFrame
*/
class wxStackWalker
{
};
+
/**
@class wxStackFrame
@wxheader{stackwalk.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxStackWalker
+ @see wxStackWalker
*/
class wxStackFrame
{
*/
bool HasSourceLocation() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: statbmp.h
-// Purpose: documentation for wxStaticBitmap class
+// Purpose: interface of wxStaticBitmap
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{staticbitmap.png}
- @seealso
- wxStaticBitmap, wxStaticBox
+ @see wxStaticBitmap, wxStaticBox
*/
class wxStaticBitmap : public wxControl
{
*/
virtual void SetIcon(const wxIcon& label);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: statbox.h
-// Purpose: documentation for wxStaticBox class
+// Purpose: interface of wxStaticBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{staticbox.png}
- @seealso
- wxStaticText
+ @see wxStaticText
*/
class wxStaticBox : public wxControl
{
long style = 0,
const wxString& name = "staticBox");
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: statline.h
-// Purpose: documentation for wxStaticLine class
+// Purpose: interface of wxStaticLine
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxStaticBox
+ @see wxStaticBox
*/
class wxStaticLine : public wxControl
{
*/
bool IsVertical() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: stattext.h
-// Purpose: documentation for wxStaticText class
+// Purpose: interface of wxStaticText
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{statictext.png}
- @seealso
- wxStaticBitmap, wxStaticBox
+ @see wxStaticBitmap, wxStaticBox
*/
class wxStaticText : public wxControl
{
most @a width pixels wide if possible (the lines are broken at words
boundaries so it might not be the case if words are too long). If @e width
is negative, no wrapping is done.
- This function is new since wxWidgets version 2.6.2
+
+ @wxsince{2.6.2}
*/
void Wrap(int width);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: statusbr.h
-// Purpose: documentation for wxStatusBar class
+// Purpose: interface of wxStatusBar
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{miscwnd}
- @seealso
- wxFrame, @ref overview_samplestatbar "Status bar sample"
+ @see wxFrame, @ref overview_samplestatbar "Status bar sample"
*/
class wxStatusBar : public wxWindow
{
*/
virtual void SetStatusWidths(int n, int* widths);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: stc/stc.h
-// Purpose: documentation for wxStyledTextEvent class
+// Purpose: interface of wxStyledTextEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxStyledTextCtrl
@headerfile stc.h wx/stc/stc.h
@library{wxbase}
@category{stc}
- @seealso
- wxStyledTextEvent
+ @see wxStyledTextEvent
*/
class wxStyledTextCtrl : public wxControl
{
*/
void ZoomOut();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: stdpaths.h
-// Purpose: documentation for wxStandardPaths class
+// Purpose: interface of wxStandardPaths
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{file}
- @seealso
- wxFileConfig
+ @see wxFileConfig
*/
class wxStandardPaths
{
Unix: @c ~ (the home directory)
Windows: @c C:\Documents and Settings\@e username\Documents
Mac: @c ~/Documents
- This function is new since wxWidgets version 2.7.0
+
+ @wxsince{2.7.0}
*/
wxString GetDocumentsDir() const;
@c @e lang.lproj under Mac OS X) but is something quite
different for message catalog category under Unix where it returns the standard
@c @e prefix/share/locale/@e lang/LC_MESSAGES directory.
- This function is new since wxWidgets version 2.7.0
+
+ @wxsince{2.7.0}
*/
wxString GetLocalizedResourcesDir(const wxString& lang,
ResourceCat category = ResourceCat_None) const;
Unix: @c @e prefix/share/@e appname
Windows: the directory where the executable file is located
Mac: @c @e appname.app/Contents/Resources bundle subdirectory
- This function is new since wxWidgets version 2.7.0
+
+ @wxsince{2.7.0}
@see GetLocalizedResourcesDir()
*/
files,
it is best to use wxFileName::CreateTempFileName for correct behaviour when
multiple processes are attempting to create temporary files.
- This function is new since wxWidgets version 2.7.2
+
+ @wxsince{2.7.2}
*/
wxString GetTempDir() const;
*/
void UseAppInfo(int info);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: stockitem.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// Name: stopwatch.h
-// Purpose: documentation for wxStopWatch class
+// Purpose: interface of wxStopWatch
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{misc}
- @seealso
- wxTimer
+ @see wxTimer
*/
class wxStopWatch
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: strconv.h
-// Purpose: documentation for wxMBConvUTF7 class
+// Purpose: interface of wxMBConvUTF7
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- wxMBConvUTF8, @ref overview_mbconvclasses "wxMBConv classes overview"
+ @see wxMBConvUTF8, @ref overview_mbconvclasses "wxMBConv classes overview"
*/
class wxMBConvUTF7 : public wxMBConv
{
};
+
/**
@class wxMBConvUTF8
@wxheader{strconv.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxMBConvUTF7, @ref overview_mbconvclasses "wxMBConv classes overview"
+ @see wxMBConvUTF7, @ref overview_mbconvclasses "wxMBConv classes overview"
*/
class wxMBConvUTF8 : public wxMBConv
{
};
+
/**
@class wxMBConvUTF16
@wxheader{strconv.h}
This class is used to convert between multibyte encodings and UTF-16 Unicode
- encoding (also known as UCS-2). Unlike UTF-8 encoding,
+ encoding (also known as UCS-2). Unlike UTF-8() encoding,
UTF-16 uses words and not bytes and hence depends on the byte ordering:
big or little endian. Hence this class is provided in two versions:
wxMBConvUTF16LE and wxMBConvUTF16BE and wxMBConvUTF16 itself is just a typedef
@library{wxbase}
@category{FIXME}
- @seealso
- wxMBConvUTF8, wxMBConvUTF32, @ref overview_mbconvclasses "wxMBConv classes
+ @see wxMBConvUTF8, wxMBConvUTF32, @ref overview_mbconvclasses "wxMBConv classes
overview"
*/
class wxMBConvUTF16 : public wxMBConv
};
+
/**
@class wxCSConv
@wxheader{strconv.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxMBConv, wxEncodingConverter, @ref overview_mbconvclasses "wxMBConv classes
- overview"
+ @see wxMBConv, wxEncodingConverter, @ref overview_mbconvclasses "wxMBConv
+ classes overview"
*/
class wxCSConv : public wxMBConv
{
available to use. Returns @false if ISO 8859-1 will be used instead.
Note this does not mean that a given string will be correctly converted.
A malformed string may still make conversion functions return @c wxCONV_FAILED.
- This function is new since wxWidgets version 2.8.2
+
+ @wxsince{2.8.2}
*/
bool IsOk() const;
};
+
/**
@class wxMBConvFile
@wxheader{strconv.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_mbconvclasses "wxMBConv classes overview"
+ @see @ref overview_mbconvclasses "wxMBConv classes overview"
*/
class wxMBConvFile : public wxMBConv
{
};
+
/**
@class wxMBConvUTF32
@wxheader{strconv.h}
This class is used to convert between multibyte encodings and UTF-32 Unicode
- encoding (also known as UCS-4). Unlike UTF-8 encoding,
+ encoding (also known as UCS-4). Unlike UTF-8() encoding,
UTF-32 uses (double) words and not bytes and hence depends on the byte ordering:
big or little endian. Hence this class is provided in two versions:
wxMBConvUTF32LE and wxMBConvUTF32BE and wxMBConvUTF32 itself is just a typedef
@library{wxbase}
@category{FIXME}
- @seealso
- wxMBConvUTF8, wxMBConvUTF16, @ref overview_mbconvclasses "wxMBConv classes
+ @see wxMBConvUTF8, wxMBConvUTF16, @ref overview_mbconvclasses "wxMBConv classes
overview"
*/
class wxMBConvUTF32 : public wxMBConv
};
+
/**
@class wxMBConv
@wxheader{strconv.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxCSConv, wxEncodingConverter, @ref overview_mbconvclasses "wxMBConv classes
- overview"
+ @see wxCSConv, wxEncodingConverter, @ref overview_mbconvclasses "wxMBConv
+ classes overview"
*/
class wxMBConv
{
const const wxWCharBuffer cWX2WC(const wxChar* psz) const;
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: stream.h
-// Purpose: documentation for wxCountingOutputStream class
+// Purpose: interface of wxCountingOutputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxBufferedInputStream
@wxheader{stream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxStreamBuffer, wxInputStream, wxBufferedOutputStream
+ @see wxStreamBuffer, wxInputStream, wxBufferedOutputStream
*/
class wxBufferedInputStream : public wxFilterInputStream
{
};
+
/**
@class wxStreamBuffer
@wxheader{stream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxStreamBase
+ @see wxStreamBase
*/
class wxStreamBuffer
{
};
+
/**
@class wxOutputStream
@wxheader{stream.h}
};
+
/**
@class wxFilterClassFactory
@wxheader{stream.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxFilterInputStream, wxFilterOutputStream, wxArchiveClassFactory, @ref
+ @see wxFilterInputStream, wxFilterOutputStream, wxArchiveClassFactory, @ref
overview_wxarc "Archive formats such as zip"
*/
class wxFilterClassFactory : public wxObject
};
+
/**
@class wxFilterOutputStream
@wxheader{stream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxFilterClassFactory, wxFilterInputStream
+ @see wxFilterClassFactory, wxFilterInputStream
*/
class wxFilterOutputStream : public wxOutputStream
{
};
+
/**
@class wxFilterInputStream
@wxheader{stream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxFilterClassFactory, wxFilterOutputStream
+ @see wxFilterClassFactory, wxFilterOutputStream
*/
class wxFilterInputStream : public wxInputStream
{
};
+
/**
@class wxBufferedOutputStream
@wxheader{stream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxStreamBuffer, wxOutputStream
+ @see wxStreamBuffer, wxOutputStream
*/
class wxBufferedOutputStream : public wxFilterOutputStream
{
};
+
/**
@class wxInputStream
@wxheader{stream.h}
};
+
/**
@class wxStreamBase
@wxheader{stream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxStreamBuffer
+ @see wxStreamBuffer
*/
class wxStreamBase
{
Returns the length of the stream in bytes. If the length cannot be determined
(this is always the case for socket streams for example), returns
@c wxInvalidOffset.
- This function is new since wxWidgets version 2.5.4
+
+ @wxsince{2.5.4}
*/
wxFileOffset GetLength() const;
*/
size_t OnSysWrite(const void* buffer, size_t bufsize);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: string.h
-// Purpose: documentation for wxStringBuffer class
+// Purpose: interface of wxStringBuffer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxString
@wxheader{string.h}
@category{data}
@stdobjects
- Objects:
- wxEmptyString
+ ::Objects:, ::wxEmptyString,
- @seealso
- @ref overview_wxstringoverview "wxString overview", @ref overview_unicode
+ @see @ref overview_wxstringoverview "wxString overview", @ref overview_unicode
"Unicode overview"
*/
class wxString
This section also contains both implicit and explicit conversions to C style
strings. Although implicit conversion is quite convenient, it is advised to use
explicit @ref cstr() c_str method for the sake of clarity. Also
- see overview for the cases where it is necessary to
+ see overview() for the cases where it is necessary to
use it.
GetChar()
build, the string is interpreted as being in ISO-8859-1 encoding. The version
without @a len parameter takes NUL-terminated data.
This is a convenience method useful when storing binary data in wxString.
- This function is new since wxWidgets version 2.8.4
+
+ @wxsince{2.8.4}
@see wxString::To8BitData
*/
Converts the string to an 8-bit string in ISO-8859-1 encoding in the form of
a wxCharBuffer (Unicode builds only).
This is a convenience method useful when storing binary data in wxString.
- This function is new since wxWidgets version 2.8.4
+
+ @wxsince{2.8.4}
@see wxString::From8BitData
*/
};
+/**
+ FIXME
+*/
+wxString Objects:
+;
+
+/**
+ FIXME
+*/
+wxString wxEmptyString;
+
+
+
+
/**
@class wxStringBufferLength
@wxheader{string.h}
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
//@{
/**
Converts its argument to string.
- See also: wxFromString.
+ 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.
+ See also: wxToString().
*/
bool wxFromString(const wxString& str, wxColour* col);
bool wxFromString(const wxString& str, wxFont* col);
/////////////////////////////////////////////////////////////////////////////
// Name: sysopt.h
-// Purpose: documentation for wxSystemOptions class
+// Purpose: interface of wxSystemOptions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{misc}
- @seealso
- wxSystemOptions::SetOption, wxSystemOptions::GetOptionInt,
+ @see wxSystemOptions::SetOption, wxSystemOptions::GetOptionInt,
wxSystemOptions::HasOption
*/
class wxSystemOptions : public wxObject
void SetOption(const wxString& name, int value);
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: tarstrm.h
-// Purpose: documentation for wxTarInputStream class
+// Purpose: interface of wxTarInputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{streams}
- @seealso
- @ref overview_wxarcbyname "Looking up an archive entry by name"
+ @see @ref overview_wxarcbyname "Looking up an archive entry by name"
*/
class wxTarInputStream : public wxArchiveInputStream
{
};
+
/**
@class wxTarClassFactory
@wxheader{tarstrm.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", @ref overview_wxarcgeneric
- "Generic archive programming", wxTarEntry, wxTarInputStream, wxTarOutputStream
+ @see @ref overview_wxarc "Archive formats such as zip", @ref
+ overview_wxarcgeneric "Generic archive programming", wxTarEntry, wxTarInputStream, wxTarOutputStream
*/
class wxTarClassFactory : public wxArchiveClassFactory
{
};
+
/**
@class wxTarOutputStream
@wxheader{tarstrm.h}
@library{wxbase}
@category{streams}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", wxTarEntry, wxTarInputStream
+ @see @ref overview_wxarc "Archive formats such as zip", wxTarEntry,
+ wxTarInputStream
*/
class wxTarOutputStream : public wxArchiveOutputStream
{
};
+
/**
@class wxTarEntry
@wxheader{tarstrm.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", wxTarInputStream,
+ @see @ref overview_wxarc "Archive formats such as zip", wxTarInputStream,
wxTarOutputStream
*/
class wxTarEntry : public wxArchiveEntry
*/
wxTarEntry& operator operator=(const wxTarEntry& entry);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: taskbar.h
-// Purpose: documentation for wxTaskBarIcon class
+// Purpose: interface of wxTaskBarIcon
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
bool SetIcon(const wxIcon& icon, const wxString& tooltip);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: textctrl.h
-// Purpose: documentation for wxTextAttr class
+// Purpose: interface of wxTextAttr
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{richtext}
- @seealso
- wxTextCtrl, wxRichTextCtrl
+ @see wxTextCtrl, wxRichTextCtrl
*/
class wxTextAttr
{
};
+
/**
@class wxTextCtrl
@wxheader{textctrl.h}
@category{ctrl}
@appearance{textctrl.png}
- @seealso
- wxTextCtrl::Create, wxValidator
+ @see wxTextCtrl::Create, wxValidator
*/
class wxTextCtrl : public wxControl
{
text control using the given @e choices.
Notice that currently this function is only implemented in wxGTK2 and wxMSW
ports and does nothing under the other platforms.
- This function is new since wxWidgets version 2.9.0
+
+ @wxsince{2.9.0}
@returns @true if the auto-completion was enabled or @false if the
operation failed, typically because auto-completion is
text control using all valid file system paths.
Notice that currently this function is only implemented in wxGTK2 port and does
nothing under the other platforms.
- This function is new since wxWidgets version 2.9.0
+
+ @wxsince{2.9.0}
@returns @true if the auto-completion was enabled or @false if the
operation failed, typically because auto-completion is
event.
This is the only difference with SetValue().
See @ref overview_progevent "this topic" for more information.
- This function is new since wxWidgets version 2.7.1
+
+ @wxsince{2.7.1}
@param value
The new value to set. It may contain newline characters if the text control
Returns @true if the control is currently empty. This is the same as
@c GetValue().empty() but can be much more efficient for the multiline
controls containing big amounts of text.
- This function is new since wxWidgets version 2.7.1
+
+ @wxsince{2.7.1}
*/
bool IsEmpty() const;
};
+
/**
@class wxStreamToTextRedirector
@wxheader{textctrl.h}
@library{wxcore}
@category{logging}
- @seealso
- wxTextCtrl
+ @see wxTextCtrl
*/
class wxStreamToTextRedirector
{
*/
~wxStreamToTextRedirector();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: textdlg.h
-// Purpose: documentation for wxPasswordEntryDialog class
+// Purpose: interface of wxPasswordEntryDialog
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{cmndlg}
- @seealso
- @ref overview_wxpasswordentrydialogoverview "wxPassowrdEntryDialog overview"
+ @see @ref overview_wxpasswordentrydialogoverview "wxPassowrdEntryDialog
+ overview"
*/
class wxPasswordEntryDialog : public wxTextEntryDialog
{
};
+
/**
@class wxTextEntryDialog
@wxheader{textdlg.h}
@library{wxbase}
@category{cmndlg}
- @seealso
- @ref overview_wxtextentrydialogoverview "wxTextEntryDialog overview"
+ @see @ref overview_wxtextentrydialogoverview "wxTextEntryDialog overview"
*/
class wxTextEntryDialog : public wxDialog
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
bool centre = true);
/**
- Similar to wxGetTextFromUser but the text entered
+ Similar to wxGetTextFromUser() but the text entered
in the dialog is not shown on screen but replaced with stars. This is intended
to be used for entering passwords as the function name implies.
*/
/////////////////////////////////////////////////////////////////////////////
// Name: textfile.h
-// Purpose: documentation for wxTextFile class
+// Purpose: interface of wxTextFile
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{file}
- @seealso
- wxFile
+ @see wxFile
*/
class wxTextFile
{
*/
wxString operator[](size_t n) const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: tglbtn.h
-// Purpose: documentation for wxBitmapToggleButton class
+// Purpose: interface of wxBitmapToggleButton
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxToggleButton
@wxheader{tglbtn.h}
Since wxWidgets version 2.9.0 this control emits an update UI event.
You can see wxToggleButton in action in the sixth page of the
- controls sample.
+ controls() sample.
@beginEventTable
@event{EVT_TOGGLEBUTTON(id, func)}:
@category{ctrl}
@appearance{togglebutton.png}
- @seealso
- wxCheckBox, wxButton, wxBitmapToggleButton
+ @see wxCheckBox, wxButton, wxBitmapToggleButton
*/
class wxToggleButton : public wxControl
{
*/
void SetValue(bool state);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: thread.h
-// Purpose: documentation for wxCondition class
+// Purpose: interface of wxCondition
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{thread}
- @seealso
- wxThread, wxMutex
+ @see wxThread, wxMutex
*/
class wxCondition
{
};
+
/**
@class wxCriticalSectionLocker
@wxheader{thread.h}
@library{wxbase}
@category{thread}
- @seealso
- wxCriticalSection, wxMutexLocker
+ @see wxCriticalSection, wxMutexLocker
*/
class wxCriticalSectionLocker
{
};
+
/**
@class wxThreadHelper
@wxheader{thread.h}
@library{wxbase}
@category{thread}
- @seealso
- wxThread
+ @see wxThread
*/
class wxThreadHelper
{
};
+
/**
@class wxCriticalSection
@wxheader{thread.h}
A critical section object is used for exactly the same purpose as
- mutexes. The only difference is that under Windows platform
+ mutexes(). The only difference is that under Windows platform
critical sections are only visible inside one process, while mutexes may be
shared between processes, so using critical sections is slightly more
efficient. The terminology is also slightly different: mutex may be locked (or
@library{wxbase}
@category{thread}
- @seealso
- wxThread, wxCondition, wxCriticalSectionLocker
+ @see wxThread, wxCondition, wxCriticalSectionLocker
*/
class wxCriticalSection
{
};
+
/**
@class wxThread
@wxheader{thread.h}
also
makes it much easier to shoot oneself in the foot, so careful use of
synchronization
- objects such as mutexes or @ref overview_wxcriticalsection "critical sections"
- is recommended. In addition, don't create global thread
+ objects such as mutexes() or @ref overview_wxcriticalsection "critical
+ sections" is recommended. In addition, don't create global thread
objects because they allocate memory in their constructor, which will cause
problems for the memory checking system.
@library{wxbase}
@category{thread}
- @seealso
- wxMutex, wxCondition, wxCriticalSection
+ @see wxMutex, wxCondition, wxCriticalSection
*/
class wxThread
{
in fact calling a routine on any running wxThread should be avoided if
possible. Instead, find a way to notify yourself when the thread has ended.
Usually you only need to notify the main thread, in which case you can post
- an event to it via wxPostEvent or
+ an event to it via wxPostEvent() or
wxEvtHandler::AddPendingEvent. In
the case of secondary threads you can call a routine of another class
when the thread is about to complete processing and/or set the value
- of a variable, possibly using mutexes and/or other
+ of a variable, possibly using mutexes() and/or other
synchronization means if necessary.
*/
/**
Pauses the thread execution for the given amount of time.
- This function should be used instead of wxSleep by all worker
+ This function should be used instead of wxSleep() by all worker
threads (i.e. all except the main one).
*/
static void Sleep(unsigned long milliseconds);
and could end your application prematurely. This is due to several reasons,
including the underlying native API and the fact that wxThread does not run a
GUI event loop similar to other APIs as MFC.
- A workaround that works on some wxWidgets ports is calling wxMutexGUIEnter
- before any GUI calls and then calling wxMutexGUILeave afterwords. However,
+ A workaround that works on some wxWidgets ports is calling wxMutexGUIEnter()
+ before any GUI calls and then calling wxMutexGUILeave() afterwords. However,
the recommended way is to simply process the GUI calls in the main thread
- through an event that is posted by either wxPostEvent or
+ through an event that is posted by either wxPostEvent() or
wxEvtHandler::AddPendingEvent. This does
not imply that calls to these classes are thread-safe, however, as most
wxWidgets classes are not thread-safe, including wxString.
};
+
/**
@class wxSemaphore
@wxheader{thread.h}
};
+
/**
@class wxMutexLocker
@wxheader{thread.h}
@library{wxbase}
@category{thread}
- @seealso
- wxMutex, wxCriticalSectionLocker
+ @see wxMutex, wxCriticalSectionLocker
*/
class wxMutexLocker
{
};
+
/**
@class wxMutex
@wxheader{thread.h}
@library{wxbase}
@category{thread}
- @seealso
- wxThread, wxCondition, wxMutexLocker, wxCriticalSection
+ @see wxThread, wxCondition, wxMutexLocker, wxCriticalSection
*/
class wxMutex
{
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
bool wxIsMainThread();
/**
- This macro combines wxCRIT_SECT_DECLARE and
- wxCRIT_SECT_LOCKER: it creates a static critical
+ This macro combines wxCRIT_SECT_DECLARE() and
+ wxCRIT_SECT_LOCKER(): it creates a static critical
section object and also the lock object associated with it. Because of this, it
can be only used inside a function, not at global scope. For example:
This macro declares a critical section object named @a cs if
@c wxUSE_THREADS is 1 and does nothing if it is 0. As it doesn't
include the @c static keyword (unlike
- wxCRIT_SECT_DECLARE), it can be used to declare
+ wxCRIT_SECT_DECLARE()), it can be used to declare
a class or struct member which explains its name.
*/
#define wxCRIT_SECT_DECLARE(cs) /* implementation is private */
/////////////////////////////////////////////////////////////////////////////
// Name: timer.h
-// Purpose: documentation for wxTimer class
+// Purpose: interface of wxTimer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{misc}
- @seealso
- wxStopWatch
+ @see wxStopWatch
*/
class wxTimer : public wxEvtHandler
{
};
+
/**
@class wxTimerEvent
@wxheader{timer.h}
@library{wxbase}
@category{events}
- @seealso
- wxTimer
+ @see wxTimer
*/
class wxTimerEvent : public wxEvent
{
*/
wxTimer GetTimer() const;
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: tipdlg.h
-// Purpose: documentation for wxTipProvider class
+// Purpose: interface of wxTipProvider
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@class wxTipProvider
@wxheader{tipdlg.h}
- This is the class used together with wxShowTip function.
+ This is the class used together with wxShowTip() function.
It must implement wxTipProvider::GetTip function and return the
current tip from it (different tip each time it is called).
You will never use this class yourself, but you need it to show startup tips
with wxShowTip. Also, if you want to get the tips text from elsewhere than a
simple text file, you will want to derive a new class from wxTipProvider and
- use it instead of the one returned by wxCreateFileTipProvider.
+ use it instead of the one returned by wxCreateFileTipProvider().
@library{wxadv}
@category{FIXME}
- @seealso
- @ref overview_tipsoverview "Startup tips overview", ::wxShowTip
+ @see @ref overview_tipsoverview "Startup tips overview", ::wxShowTip
*/
class wxTipProvider
{
Returns the index of the current tip (i.e. the one which would be returned by
GetTip).
The program usually remembers the value returned by this function after calling
- wxShowTip. Note that it is not the same as the value which
+ wxShowTip(). Note that it is not the same as the value which
was passed to wxShowTip + 1 because the user might have pressed the "Next"
button in the tip dialog.
*/
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/**
This function creates a wxTipProvider which may be
- used with wxShowTip.
+ used with wxShowTip().
@param filename
The name of the file containing the tips, one per line
/////////////////////////////////////////////////////////////////////////////
// Name: tipwin.h
-// Purpose: documentation for wxTipWindow class
+// Purpose: interface of wxTipWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
void SetTipWindowPtr(wxTipWindow** windowPtr);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: tokenzr.h
-// Purpose: documentation for wxStringTokenizer class
+// Purpose: interface of wxStringTokenizer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{data}
- @seealso
- wxStringTokenize
+ @see wxStringTokenize()
*/
class wxStringTokenizer : public wxObject
{
GetNextToken() or @c NUL if
there had been no calls to this function yet or if it returned the trailing
empty token in @c wxTOKEN_RET_EMPTY_ALL mode.
- This function is new since wxWidgets version 2.7.0
+
+ @wxsince{2.7.0}
*/
wxChar GetLastDelimiter();
const wxString& delims = " \t\r\n",
wxStringTokenizerMode mode = wxTOKEN_DEFAULT);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: toolbar.h
-// Purpose: documentation for wxToolBar class
+// Purpose: interface of wxToolBar
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{miscwnd}
- @seealso
- @ref overview_wxtoolbaroverview "Toolbar overview", wxScrolledWindow
+ @see @ref overview_wxtoolbaroverview "Toolbar overview", wxScrolledWindow
*/
class wxToolBar : public wxControl
{
*/
void ToggleTool(int toolId, bool toggle);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: toolbook.h
-// Purpose: documentation for wxToolbook class
+// Purpose: interface of wxToolbook
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxBookCtrl, wxNotebook, @ref overview_samplenotebook "notebook sample"
+ @see wxBookCtrl(), wxNotebook, @ref overview_samplenotebook "notebook sample"
*/
class wxToolbook : public wxBookCtrl overview
{
public:
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: tooltip.h
-// Purpose: documentation for wxToolTip class
+// Purpose: interface of wxToolTip
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
void SetTip(const wxString& tip);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: toplevel.h
-// Purpose: documentation for wxTopLevelWindow class
+// Purpose: interface of wxTopLevelWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{managedwnd}
- @seealso
- wxTopLevelWindow::SetTransparent
+ @see wxTopLevelWindow::SetTransparent
*/
class wxTopLevelWindow : public wxWindow
{
*/
void UseNativeDecorationsByDefault(bool native = true);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: tracker.h
-// Purpose: documentation for wxTrackable class
+// Purpose: interface of wxTrackable
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
Add-on base class for a trackable object. This class maintains
an internal linked list of classes of type wxTrackerNode and
calls OnObjectDestroy() on them if this object is destroyed.
- The most common usage is by using the wxWeakRefT
+ The most common usage is by using the wxWeakRefT()
class template which automates this. This class has no public
API. Its only use is by deriving another class from it to
make it trackable.
public:
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: treebase.h
-// Purpose: documentation for wxTreeItemId class
+// Purpose: interface of wxTreeItemId
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxTreeCtrl, wxTreeItemData, @ref overview_wxtreectrloverview "wxTreeCtrl
+ @see wxTreeCtrl, wxTreeItemData, @ref overview_wxtreectrloverview "wxTreeCtrl
overview"
*/
class wxTreeItemId
const bool operator !=(const wxTreeItemId& item) const;
//@}
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: treebook.h
-// Purpose: documentation for wxTreebookEvent class
+// Purpose: interface of wxTreebookEvent
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{events}
- @seealso
- wxNotebookEvent, wxTreebook
+ @see wxNotebookEvent, wxTreebook
*/
class wxTreebookEvent : public wxNotifyEvent
{
};
+
/**
@class wxTreebook
@wxheader{treebook.h}
@library{wxcore}
@category{miscwnd}
- @seealso
- wxNotebook, wxTreebookEvent, wxImageList, @ref overview_samplenotebook
+ @see wxNotebook, wxTreebookEvent, wxImageList, @ref overview_samplenotebook
"notebook sample"
*/
class wxTreebook : public wxBookCtrl overview
*/
int SetSelection(size_t n);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: treectrl.h
-// Purpose: documentation for wxTreeItemData class
+// Purpose: interface of wxTreeItemData
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxTreeCtrl
+ @see wxTreeCtrl
*/
class wxTreeItemData : public wxClientData
{
};
+
/**
@class wxTreeCtrl
@wxheader{treectrl.h}
@category{ctrl}
@appearance{treectrl.png}
- @seealso
- wxTreeItemData, @ref overview_wxtreectrloverview "wxTreeCtrl overview",
+ @see wxTreeItemData, @ref overview_wxtreectrloverview "wxTreeCtrl overview",
wxListBox, wxListCtrl, wxImageList, wxTreeEvent
*/
class wxTreeCtrl : public wxControl
positive value if the first item is less than, equal to or greater than the
second one.
Please note that you @b must use wxRTTI macros
- DECLARE_DYNAMIC_CLASS and
- IMPLEMENT_DYNAMIC_CLASS if you override this
+ DECLARE_DYNAMIC_CLASS() and
+ IMPLEMENT_DYNAMIC_CLASS() if you override this
function because otherwise the base class considers that it is not overridden
and uses the default comparison, i.e. sorts the items alphabetically, which
allows it optimize away the calls to the virtual function completely.
};
+
/**
@class wxTreeEvent
@wxheader{treectrl.h}
@library{wxbase}
@category{events}
- @seealso
- wxTreeCtrl
+ @see wxTreeCtrl
*/
class wxTreeEvent : public wxNotifyEvent
{
*/
void SetToolTip(const wxString& tooltip);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: txtstrm.h
-// Purpose: documentation for wxTextInputStream class
+// Purpose: interface of wxTextInputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{streams}
- @seealso
- wxTextInputStream::SetStringSeparators
+ @see wxTextInputStream::SetStringSeparators
*/
class wxTextInputStream
{
};
+
/**
@class wxTextOutputStream
@wxheader{txtstrm.h}
*/
virtual void WriteString(const wxString& string);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: uri.h
-// Purpose: documentation for wxURI class
+// Purpose: interface of wxURI
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{data}
- @seealso
- wxURL
+ @see wxURL
*/
class wxURI : public wxObject
{
*/
void operator ==(const wxURI& uricomp);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: url.h
-// Purpose: documentation for wxURL class
+// Purpose: interface of wxURL
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxnet}
@category{net}
- @seealso
- wxSocketBase, wxProtocol
+ @see wxSocketBase, wxProtocol
*/
class wxURL : public wxURI
{
*/
wxURLError SetURL(const wxString& url);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: utils.h
-// Purpose: documentation for wxWindowDisabler class
+// Purpose: interface of wxWindowDisabler
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxBusyCursor
+ @see wxBusyCursor
*/
class wxWindowDisabler
{
};
+
/**
@class wxBusyCursor
@wxheader{utils.h}
DoACalculation();
@endcode
- It works by calling wxBeginBusyCursor in the constructor,
- and wxEndBusyCursor in the destructor.
+ It works by calling wxBeginBusyCursor() in the constructor,
+ and wxEndBusyCursor() in the destructor.
@library{wxcore}
@category{FIXME}
- @seealso
- wxBeginBusyCursor, wxEndBusyCursor, wxWindowDisabler
+ @see wxBeginBusyCursor(), wxEndBusyCursor(), wxWindowDisabler
*/
class wxBusyCursor
{
public:
/**
- Constructs a busy cursor object, calling wxBeginBusyCursor.
+ Constructs a busy cursor object, calling wxBeginBusyCursor().
*/
wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR);
/**
- Destroys the busy cursor object, calling wxEndBusyCursor.
+ Destroys the busy cursor object, calling wxEndBusyCursor().
*/
~wxBusyCursor();
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
empty string otherwise. The second (deprecated) function returns @true
if successful, @false otherwise.
- @see wxGetUserName
+ @see wxGetUserName()
*/
wxString wxGetUserId();
bool wxGetUserId(char* buf, int sz);
/**
@b NB: This function is now obsolete, please use
- wxLogFatalError instead.
+ wxLogFatalError() instead.
Displays @a msg and exits. This writes to standard error under Unix,
and pops up a message box under Windows. Used for fatal internal
- wxWidgets errors. See also wxError.
+ wxWidgets errors. See also wxError().
*/
void wxFatalError(const wxString& msg,
const wxString& title = "wxWidgets Fatal Error");
/**
Changes the cursor back to the original cursor, for all windows in the
application.
- Use with wxBeginBusyCursor.
- See also wxIsBusy, wxBusyCursor.
+ Use with wxBeginBusyCursor().
+ See also wxIsBusy(), wxBusyCursor.
*/
void wxEndBusyCursor();
/**
@b NB: This function is now obsolete, replaced by Log
- functions and wxLogDebug in particular.
+ functions() and wxLogDebug() in particular.
Display a debugging message; under Windows, this will appear on the
debugger command window, and under Unix, it will be written to standard
error.
/**
Return the (current) user's home directory.
- @see wxGetUserHome, wxStandardPaths
+ @see wxGetUserHome(), wxStandardPaths
*/
wxString wxGetHomeDir();
Sleeps for the specified number of microseconds. The microsecond resolution may
not, in fact, be available on all platforms (currently only Unix platforms with
nanosleep(2) may provide it) in which case this is the same as
- wxMilliSleep(@e microseconds/1000).
+ wxMilliSleep()(@e microseconds/1000).
*/
void wxMicroSleep(unsigned long microseconds);
underlying GUI toolkit. This is mainly used for diagnostic purposes and can be
invoked by Ctrl-Alt-middle clicking on any wxWindow which doesn't otherwise
handle this event.
- This function is new since wxWidgets version 2.9.0
+
+ @wxsince{2.9.0}
*/
void wxInfoMessageBox(wxWindow ( parent = NULL);
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.
Displays @a msg and continues. This writes to standard error under
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,
const wxString& title = "wxWidgets Internal Error");
/**
Executes a command in an interactive shell window. If no command is
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);
Returns the FQDN (fully qualified domain host name) or an empty string on
error.
- @see wxGetHostName
+ @see wxGetHostName()
*/
wxString wxGetFullHostName();
/**
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
ensures that only the outer calls take effect.
- See also wxIsBusy, wxBusyCursor.
+ See also wxIsBusy(), wxBusyCursor.
*/
void wxBeginBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR);
This is a macro defined as @c getenv() or its wide char version in Unicode
mode.
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.
*/
wxChar* wxGetEnv(const wxString& var);
empty string otherwise. The second (deprecated) function returns @true
if successful, @false otherwise.
- @see wxGetFullHostName
+ @see wxGetFullHostName()
*/
wxString wxGetHostName();
bool wxGetHostName(char* buf, int sz);
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();
/**
Returns the home directory for the given user. If the @a user is empty
(default value), this function behaves like
- wxGetHomeDir i.e. returns the current user home
+ wxGetHomeDir() i.e. returns the current user home
directory.
If the home directory couldn't be determined, an empty string is returned.
*/
the process (which terminates by the moment the function returns) and will be
-1 if the process couldn't be started and typically 0 if the process
terminated successfully. Also, while waiting for the process to
- terminate, wxExecute will call wxYield. Because of this, by
+ terminate, wxExecute will call wxYield(). Because of this, by
default this function disables all application windows to avoid unexpected
reentrancies which could result from the users interaction with the program
while the child process is running. If you are sure that it is safe to not
happening, i.e. with this flag the child process window will be shown normally.
Under Unix the flag @c wxEXEC_MAKE_GROUP_LEADER may be used to ensure
that the new process is a group leader (this will create a new session if
- needed). Calling wxKill passing wxKILL_CHILDREN will
+ needed). Calling wxKill() passing wxKILL_CHILDREN will
kill this process as well as all of its children (except those which have
started their own session).
The @c wxEXEC_NOEVENTS flag prevents processing of any events from taking
@param callback
An optional pointer to wxProcess
- @see wxShell, wxProcess, @ref overview_sampleexec "Exec sample".
+ @see wxShell(), wxProcess, @ref overview_sampleexec "Exec sample".
*/
long wxExecute(const wxString& command, int sync = wxEXEC_ASYNC,
wxProcess* callback = NULL);
wxMouseState wxGetMouseState();
/**
- Returns @true if between two wxBeginBusyCursor and
- wxEndBusyCursor calls.
+ Returns @true if between two wxBeginBusyCursor() and
+ wxEndBusyCursor() calls.
See also wxBusyCursor.
*/
bool wxIsBusy();
//@{
/**
Copies the user's email address into the supplied buffer, by
- concatenating the values returned by wxGetFullHostName
- and wxGetUserId.
+ concatenating the values returned by wxGetFullHostName()
+ and wxGetUserId().
Returns @true if successful, @false otherwise.
*/
wxString wxGetEmailAddress();
to @e value.
Returns @true on success.
- @see wxUnsetEnv
+ @see wxUnsetEnv()
*/
bool wxSetEnv(const wxString& var, const wxString& value);
windows from this point on. Setting the display within an application allows
multiple
displays to be used.
- See also wxGetDisplayName.
+ See also wxGetDisplayName().
*/
void wxSetDisplayName(const wxString& displayName);
/////////////////////////////////////////////////////////////////////////////
// Name: valgen.h
-// Purpose: documentation for wxGenericValidator class
+// Purpose: interface of wxGenericValidator
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{validator}
- @seealso
- @ref overview_validatoroverview "Validator overview", wxValidator,
+ @see @ref overview_validatoroverview "Validator overview", wxValidator,
wxTextValidator
*/
class wxGenericValidator : public wxValidator
*/
virtual bool TransferToWindow();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: validate.h
-// Purpose: documentation for wxValidator class
+// Purpose: interface of wxValidator
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{validator}
- @seealso
- @ref overview_validatoroverview "Validator overview", wxTextValidator,
+ @see @ref overview_validatoroverview "Validator overview", wxTextValidator,
wxGenericValidator,
*/
class wxValidator : public wxEvtHandler
*/
virtual bool Validate(wxWindow* parent);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: valtext.h
-// Purpose: documentation for wxTextValidator class
+// Purpose: interface of wxTextValidator
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{validator}
- @seealso
- @ref overview_validatoroverview "Validator overview", wxValidator,
+ @see @ref overview_validatoroverview "Validator overview", wxValidator,
wxGenericValidator
*/
class wxTextValidator : public wxValidator
*/
virtual bool Validate(wxWindow* parent);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: variant.h
-// Purpose: documentation for wxVariant class
+// Purpose: interface of wxVariant
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{data}
- @seealso
- wxVariantData
+ @see wxVariantData
*/
class wxVariant : public wxObject
{
};
+
/**
@class wxVariantData
@wxheader{variant.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxVariant
+ @see wxVariant
*/
class wxVariantData
{
*/
classname* wxGetVariantCast();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: vector.h
-// Purpose: documentation for wxVector<T> class
+// Purpose: interface of wxVector<T>
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxcontaineroverview, wxListT, wxArrayT
+ @see @ref overview_wxcontaineroverview, wxListT(), wxArrayT()
*/
class wxVector<T>
{
*/
void reserve(size_type n);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: vlbox.h
-// Purpose: documentation for wxVListBox class
+// Purpose: interface of wxVListBox
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@category{ctrl}
@appearance{vlistbox.png}
- @seealso
- wxSimpleHtmlListBox, wxHtmlListBox
+ @see wxSimpleHtmlListBox, wxHtmlListBox
*/
class wxVListBox : public wxVScrolledWindow
{
*/
void Toggle(size_t item);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: vscroll.h
-// Purpose: documentation for wxVarHScrollHelper class
+// Purpose: interface of wxVarHScrollHelper
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
class wxVarHScrollHelper : public wxVarScrollHelperBase
{
};
+
/**
@class wxVarVScrollHelper
@wxheader{vscroll.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
class wxVarVScrollHelper : public wxVarScrollHelperBase
{
};
+
/**
@class wxVarScrollHelperBase
@wxheader{vscroll.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
class wxVarScrollHelperBase
{
};
+
/**
@class wxVScrolledWindow
@wxheader{vscroll.h}
@library{wxcore}
@category{miscwnd}
- @seealso
- wxHScrolledWindow, wxHVScrolledWindow
+ @see wxHScrolledWindow, wxHVScrolledWindow
*/
class wxVScrolledWindow : public wxPanel
{
};
+
/**
@class wxHVScrolledWindow
@wxheader{vscroll.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxHScrolledWindow, wxVScrolledWindow
+ @see wxHScrolledWindow, wxVScrolledWindow
*/
class wxHVScrolledWindow : public wxPanel
{
};
+
/**
@class wxVarHVScrollHelper
@wxheader{vscroll.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
class wxVarHVScrollHelper : public wxVarVScrollHelper
{
};
+
/**
@class wxHScrolledWindow
@wxheader{vscroll.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHVScrolledWindow, wxVScrolledWindow
*/
class wxHScrolledWindow : public wxPanel
{
long style = 0,
const wxString& name = wxPanelNameStr);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: weakref.h
-// Purpose: documentation for wxWeakRefDynamic<T> class
+// Purpose: interface of wxWeakRefDynamic<T>
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
};
+
/**
@class wxWeakRefT
@wxheader{weakref.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxSharedPtr, wxScopedPtr
+ @see wxSharedPtr, wxScopedPtr
*/
class wxWeakRef<T>
{
*/
T* operator=(T* pobj);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: wfstream.h
-// Purpose: documentation for wxTempFileOutputStream class
+// Purpose: interface of wxTempFileOutputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{streams}
- @seealso
- wxTempFile
+ @see wxTempFile
*/
class wxTempFileOutputStream : public wxOutputStream
{
};
+
/**
@class wxFFileOutputStream
@wxheader{wfstream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxBufferedOutputStream, wxFFileInputStream, wxFileInputStream
+ @see wxBufferedOutputStream, wxFFileInputStream, wxFileInputStream
*/
class wxFFileOutputStream : public wxOutputStream
{
};
+
/**
@class wxFileOutputStream
@wxheader{wfstream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxBufferedOutputStream, wxFileInputStream, wxFFileInputStream
+ @see wxBufferedOutputStream, wxFileInputStream, wxFFileInputStream
*/
class wxFileOutputStream : public wxOutputStream
{
};
+
/**
@class wxFileInputStream
@wxheader{wfstream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxBufferedInputStream, wxFileOutputStream, wxFFileOutputStream
+ @see wxBufferedInputStream, wxFileOutputStream, wxFFileOutputStream
*/
class wxFileInputStream : public wxInputStream
{
};
+
/**
@class wxFFileInputStream
@wxheader{wfstream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxBufferedInputStream, wxFFileOutputStream, wxFileOutputStream
+ @see wxBufferedInputStream, wxFFileOutputStream, wxFileOutputStream
*/
class wxFFileInputStream : public wxInputStream
{
};
+
/**
@class wxFFileStream
@wxheader{wfstream.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxStreamBuffer
+ @see wxStreamBuffer
*/
class wxFFileStream : public wxFFileOutputStream
{
};
+
/**
@class wxFileStream
@wxheader{wfstream.h}
@library{wxbase}
@category{FIXME}
- @seealso
- wxStreamBuffer
+ @see wxStreamBuffer
*/
class wxFileStream : public wxFileOutputStream
{
*/
wxFileStream(const wxString& iofileName);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: window.h
-// Purpose: documentation for wxWindow class
+// Purpose: interface of wxWindow
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- @ref overview_eventhandlingoverview, @ref overview_windowsizingoverview "Window
- sizing overview"
+ @see @ref overview_eventhandlingoverview, @ref overview_windowsizingoverview
+ "Window sizing overview"
*/
class wxWindow : public wxEvtHandler
{
/**
Call this function to force one or both scrollbars to be always shown, even if
the window is big enough to show its entire contents without scrolling.
- This function is new since wxWidgets version 2.9.0
+
+ @wxsince{2.9.0}
@param hflag
Whether the horizontal scroll bar should always be visible.
static wxWindow* GetCapture();
/**
- Returns the caret associated with the window.
+ Returns the caret() associated with the window.
*/
wxCaret* GetCaret() const;
/**
Returns the next window after this one among the parent children or @NULL if
this window is the last child.
- This function is new since wxWidgets version 2.8.8
+
+ @wxsince{2.8.8}
@see GetPrevSibling()
*/
Returns the previous window before this one among the parent children or @c
@NULL if
this window is the first child.
- This function is new since wxWidgets version 2.8.8
+
+ @wxsince{2.8.8}
@see GetNextSibling()
*/
The parameters of this function are the same as for
ShowWithEffect(), please see their
description there.
- This function is new since wxWidgets version 2.9.0
+
+ @wxsince{2.9.0}
*/
virtual bool HideWithEffect(wxShowEffect effect,
unsigned timeout = 0,
/**
Create a new ID or range of IDs that are not currently in use. The
- IDs will be reserved until assigned to a wxWindowIDRef
+ IDs will be reserved until assigned to a wxWindowIDRef()
or unreserved with UnreserveControlId().
See @ref overview_windowidsoverview "Window IDs overview" for more information.
virtual void SetCanFocus(bool canFocus);
/**
- Sets the caret associated with the window.
+ Sets the caret() associated with the window.
*/
void SetCaret(wxCaret* caret) const;
for the current platform is used.
Currently this function is only implemented in wxMSW and does the same thing as
Show() in the other ports.
- This function is new since wxWidgets version 2.9.0
+
+ @wxsince{2.9.0}
@see HideWithEffect()
*/
virtual void Update();
/**
- This function sends wxUpdateUIEvents to
+ This function sends wxUpdateUIEvents() to
the window. The particular implementation depends on the window; for
example a wxToolBar will send an update UI event for each toolbar button,
and a wxFrame will send an update UI event for each menubar menu item.
};
+
// ============================================================================
// Global functions/macros
// ============================================================================
/////////////////////////////////////////////////////////////////////////////
// Name: windowid.h
-// Purpose: documentation for wxIdManager class
+// Purpose: interface of wxIdManager
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{FIXME}
- @seealso
- wxWindow::NewControlId, wxWindow::UnreserveControlId, @ref
+ @see wxWindow::NewControlId, wxWindow::UnreserveControlId, @ref
overview_windowidsoverview "Window IDs overview"
*/
class wxIdManager
/**
Called directly by wxWindow::NewControlId,
this function will create a new ID or range of IDs. The IDs will be
- reserved until assigned to a wxWindowIDRef
+ reserved until assigned to a wxWindowIDRef()
or unreserved with UnreserveControlId().
- Only ID values that are not assigned to a wxWindowIDRef
+ Only ID values that are not assigned to a wxWindowIDRef()
need to be unreserved.
@param count
*/
static wxWindowID ReserveControlId(int count = 1);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: wizard.h
-// Purpose: documentation for wxWizardPage class
+// Purpose: interface of wxWizardPage
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxadv}
@category{miscwnd}
- @seealso
- wxWizard, @ref overview_samplewizard "wxWizard sample"
+ @see wxWizard, @ref overview_samplewizard "wxWizard sample"
*/
class wxWizardPage : public wxPanel
{
};
+
/**
@class wxWizardEvent
@wxheader{wizard.h}
wxWizardEvent class represents an event generated by the
- wizard: this event is first sent to the page itself and,
+ wizard(): this event is first sent to the page itself and,
if not processed there, goes up the window hierarchy as usual.
@library{wxadv}
@category{events}
- @seealso
- wxWizard, @ref overview_samplewizard "wxWizard sample"
+ @see wxWizard, @ref overview_samplewizard "wxWizard sample"
*/
class wxWizardEvent : public wxNotifyEvent
{
};
+
/**
@class wxWizardPageSimple
@wxheader{wizard.h}
@library{wxadv}
@category{miscwnd}
- @seealso
- wxWizard, @ref overview_samplewizard "wxWizard sample"
+ @see wxWizard, @ref overview_samplewizard "wxWizard sample"
*/
class wxWizardPageSimple : public wxWizardPage
{
};
+
/**
@class wxWizard
@wxheader{wizard.h}
@library{wxadv}
@category{cmndlg}
- @seealso
- wxWizardEvent, wxWizardPage, @ref overview_samplewizard "wxWizard sample"
+ @see wxWizardEvent, wxWizardPage, @ref overview_samplewizard "wxWizard sample"
*/
class wxWizard : public wxDialog
{
*/
void SetPageSize(const wxSize& sizePage);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: wrapsizer.h
-// Purpose: documentation for wxWrapSizer class
+// Purpose: interface of wxWrapSizer
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxcore}
@category{winlayout}
- @seealso
- wxBoxSizer, wxSizer, @ref overview_sizeroverview "Sizer overview"
+ @see wxBoxSizer, wxSizer, @ref overview_sizeroverview "Sizer overview"
*/
class wxWrapSizer : public wxBoxSizer
{
bool InformFirstDirection(int direction, int size,
int availableOtherDir);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: wupdlock.h
-// Purpose: documentation for wxWindowUpdateLocker class
+// Purpose: interface of wxWindowUpdateLocker
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
*/
~wxWindowUpdateLocker();
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: wxcrt.h
-// Purpose: documentation for global functions
+// Purpose: interface of global functions
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
Returns the number of characters copied to the buffer or -1 if there is not
enough space.
- @see wxVsnprintf, wxString::Printf
+ @see wxVsnprintf(), wxString::Printf
*/
int wxSnprintf(wxChar* buf, size_t len, const wxChar* format,
...);
size_t wxStrlen(const char* p);
/**
- The same as wxSnprintf but takes a @c va_list
+ The same as wxSnprintf() but takes a @c va_list
argument instead of arbitrary number of parameters.
Note that if @c wxUSE_PRINTF_POS_PARAMS is set to 1, then this function supports
positional arguments (see wxString::Printf for more information).
parameters
even when @c wxUSE_PRINTF_POS_PARAMS is 1.
- @see wxSnprintf, wxString::PrintfV
+ @see wxSnprintf(), wxString::PrintfV
*/
int wxVsnprintf(wxChar* buf, size_t len, const wxChar* format,
va_list argPtr);
/////////////////////////////////////////////////////////////////////////////
// Name: xml/xml.h
-// Purpose: documentation for wxXmlNode class
+// Purpose: interface of wxXmlNode
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxxml}
@category{xml}
- @seealso
- wxXmlDocument, wxXmlAttribute
+ @see wxXmlDocument, wxXmlAttribute
*/
class wxXmlNode
{
};
+
/**
@class wxXmlAttribute
@headerfile xml.h wx/xml/xml.h
@library{wxxml}
@category{xml}
- @seealso
- wxXmlDocument, wxXmlNode
+ @see wxXmlDocument, wxXmlNode
*/
class wxXmlAttribute
{
};
+
/**
@class wxXmlDocument
@headerfile xml.h wx/xml/xml.h
@library{wxxml}
@category{xml}
- @seealso
- wxXmlNode, wxXmlAttribute
+ @see wxXmlNode, wxXmlAttribute
*/
class wxXmlDocument : public wxObject
{
*/
wxXmlDocument& operator operator=(const wxXmlDocument& doc);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: xrc/xmlres.h
-// Purpose: documentation for wxXmlResource class
+// Purpose: interface of wxXmlResource
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
resource. If an unknown @a str_id is requested (i.e. other than wxID_XXX
or integer), a new record is created which associates the given string with
a number. If @a value_if_not_found is @c wxID_NONE, the number is obtained via
- wxNewId. Otherwise @a value_if_not_found is used.
+ wxNewId(). Otherwise @a value_if_not_found is used.
Macro @c XRCID(name) is provided for convenient use in event tables.
*/
#define int GetXRCID(const wxString& str_id, int value_if_not_found = -2) /* implementation is private */
};
+
/**
@class wxXmlResourceHandler
@headerfile xmlres.h wx/xrc/xmlres.h
/**
)
- Creates a animation from the filename specified in @e param.
+ Creates a animation() from the filename specified in @e param.
*/
wxAnimation GetAnimation();
*/
void SetupWindow(wxWindow* wnd);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: zipstrm.h
-// Purpose: documentation for wxZipNotifier class
+// Purpose: interface of wxZipNotifier
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarcnoseek "Archives on non-seekable streams", wxZipEntry,
+ @see @ref overview_wxarcnoseek "Archives on non-seekable streams", wxZipEntry,
wxZipInputStream, wxZipOutputStream
*/
class wxZipNotifier
};
+
/**
@class wxZipEntry
@wxheader{zipstrm.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", wxZipInputStream,
+ @see @ref overview_wxarc "Archive formats such as zip", wxZipInputStream,
wxZipOutputStream, wxZipNotifier
*/
class wxZipEntry : public wxArchiveEntry
//@{
/**
- Sets the notifier for this entry.
+ Sets the notifier() for this entry.
Whenever the wxZipInputStream updates
this entry, it will then invoke the associated
notifier's wxZipNotifier::OnEntryUpdated
};
+
/**
@class wxZipInputStream
@wxheader{zipstrm.h}
@library{wxbase}
@category{streams}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", wxZipEntry, wxZipOutputStream
+ @see @ref overview_wxarc "Archive formats such as zip", wxZipEntry,
+ wxZipOutputStream
*/
class wxZipInputStream : public wxArchiveInputStream
{
};
+
/**
@class wxZipClassFactory
@wxheader{zipstrm.h}
@library{wxbase}
@category{FIXME}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", @ref overview_wxarcgeneric
- "Generic archive programming", wxZipEntry, wxZipInputStream, wxZipOutputStream
+ @see @ref overview_wxarc "Archive formats such as zip", @ref
+ overview_wxarcgeneric "Generic archive programming", wxZipEntry, wxZipInputStream, wxZipOutputStream
*/
class wxZipClassFactory : public wxArchiveClassFactory
{
};
+
/**
@class wxZipOutputStream
@wxheader{zipstrm.h}
@library{wxbase}
@category{streams}
- @seealso
- @ref overview_wxarc "Archive formats such as zip", wxZipEntry, wxZipInputStream
+ @see @ref overview_wxarc "Archive formats such as zip", wxZipEntry,
+ wxZipInputStream
*/
class wxZipOutputStream : public wxArchiveOutputStream
{
*/
void SetComment(const wxString& comment);
};
+
/////////////////////////////////////////////////////////////////////////////
// Name: zstream.h
-// Purpose: documentation for wxZlibOutputStream class
+// Purpose: interface of wxZlibOutputStream
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
@library{wxbase}
@category{streams}
- @seealso
- wxOutputStream, wxZlibInputStream
+ @see wxOutputStream, wxZlibInputStream
*/
class wxZlibOutputStream : public wxFilterOutputStream
{
};
+
/**
@class wxZlibInputStream
@wxheader{zstream.h}
@library{wxbase}
@category{streams}
- @seealso
- wxInputStream, wxZlibOutputStream.
+ @see wxInputStream, wxZlibOutputStream.
*/
class wxZlibInputStream : public wxFilterInputStream
{
*/
static bool CanHandleGZip();
};
+
projects / wxWidgets.git / commitdiff
