# creates appearance section: this should be used for all main GUI controls
ALIASES += appearance{1}="\htmlonly <br><div><span class='appearance'>Appearance:</span><br><table class='appearance'><tr><td><img src='wxmsw/\1' alt='wxMSW appearance' class='appearance'></td><td><img src='wxgtk/\1' alt='wxGTK appearance' class='appearance'></td><td><img src='wxmac/\1' alt='wxMac appearance' class='appearance'></td></tr><tr><td>wxMSW appearance</td><td>wxGTK appearance</td><td>wxMac appearance</td></tr></table></div> \endhtmlonly"
-# IMPORTANT: the \headerfile command does not work everywhere we'd need it,
-# e.g. in the constants page we need to specify an header file
-# even if they're not inside a \class, \function or \struct command:
+# Use this in grouped global functions, and macros since they
+# wouldn't otherwise indicate what header they are defined in.
ALIASES += header{1}="Include file:\n \verbatim #include <\1> \endverbatim"
-# IMPORTANT: inside a \class, we want to specify the header file only once
-# and not twice as the \headerfile command requires:
-ALIASES += wxheader{1}="\headerfile \1 wx/\1"
-
# some formatting aliases
ALIASES += true="<span class='literal'>true</span>"
ALIASES += false="<span class='literal'>false</span>"
/**
@class wxAboutDialogInfo
- @wxheader{aboutdlg.h}
wxAboutDialogInfo contains information shown in the standard @e About
dialog displayed by the wxAboutBox() function.
/**
@class wxAcceleratorEntry
- @wxheader{accel.h}
An object used by an application wishing to create an accelerator table
(see wxAcceleratorTable).
/**
@class wxAcceleratorTable
- @wxheader{accel.h}
An accelerator table allows the application to specify a table of keyboard
shortcuts for menu or button commands.
/**
@class wxAccessible
- @wxheader{access.h}
The wxAccessible class allows wxWidgets applications, and wxWidgets itself,
to return extended information about user interface elements to client
/**
@class wxAnimationCtrl
- @wxheader{animate.h}
This is a static control which displays an animation.
wxAnimationCtrl API is as simple as possible and won't give you full control
/**
@class wxAnimation
- @wxheader{animate.h}
This class encapsulates the concept of a platform-dependent animation.
An animation is a sequence of frames of the same size.
/**
@class wxAppConsole
- @wxheader{app.h}
This class is essential for writing console-only or hybrid apps without
having to define wxUSE_GUI=0.
/**
@class wxApp
- @wxheader{app.h}
The wxApp class represents the application itself. It is used to:
/**
@class wxAppTraits
- @wxheader{apptrait.h}
The wxAppTraits class defines various configurable aspects of a wxApp.
You can access it using wxApp::GetTraits() function and you can create your
/**
@class wxArchiveInputStream
- @wxheader{archive.h}
This is an abstract base class which serves as a common interface to
archive input streams such as wxZipInputStream.
/**
@class wxArchiveOutputStream
- @wxheader{archive.h}
This is an abstract base class which serves as a common interface to
archive output streams such as wxZipOutputStream.
/**
@class wxArchiveEntry
- @wxheader{archive.h}
This is an abstract base class which serves as a common interface to
archive entry classes such as wxZipEntry.
/**
@class wxArchiveClassFactory
- @wxheader{archive.h}
Allows the creation of streams to handle archive formats such as zip and tar.
/**
@class wxArchiveNotifier
- @wxheader{archive.h}
If you need to know when a wxArchiveInputStream updates a wxArchiveEntry
object, you can create a notifier by deriving from this abstract base class,
/**
@class wxArchiveIterator
- @wxheader{archive.h}
An input iterator template class that can be used to transfer an archive's
catalogue to a container. It is only available if wxUSE_STL is set to 1
/**
@class wxArrayString
- @wxheader{arrstr.h}
wxArrayString is an efficient container for storing wxString objects.
/**
@class wxSortedArrayString
- @wxheader{arrstr.h}
wxSortedArrayString is an efficient container for storing wxString objects
which always keeps the string in alphabetical order.
/**
@class wxArtProvider
- @wxheader{artprov.h}
wxArtProvider class is used to customize the look of wxWidgets application.
/**
@class wxAuiNotebook
- @headerfile auibook.h wx/aui/auibook.h
wxAuiNotebook is part of the wxAUI class framework.
See also @ref overview_aui.
/**
@class wxAuiTabArt
- @headerfile auibook.h wx/aui/auibook.h
Tab art class.
/**
@class wxAuiDockArt
- @headerfile dockart.h wx/aui/dockart.h
wxAuiDockArt is part of the wxAUI class framework.
See also @ref overview_aui.
/**
@class wxAuiManager
- @headerfile aui.h wx/aui/aui.h
wxAuiManager is the central class of the wxAUI class framework.
See also @ref overview_aui.
/**
@class wxAuiPaneInfo
- @headerfile aui.h wx/aui/aui.h
wxAuiPaneInfo is part of the wxAUI class framework.
See also @ref overview_aui.
/**
@class wxBitmapHandler
- @wxheader{bitmap.h}
This is the base class for implementing bitmap file loading/saving, and
bitmap creation from data.
/**
@class wxBitmap
- @wxheader{bitmap.h}
This class encapsulates the concept of a platform-dependent bitmap,
either monochrome or colour or colour with alpha channel support.
/**
@class wxMask
- @wxheader{bitmap.h}
This class encapsulates a monochrome mask bitmap, where the masked area is
black and the unmasked area is white.
/**
@class wxBitmapButton
- @wxheader{bmpbuttn.h}
A bitmap button is a control that contains a bitmap.
It may be placed on a wxDialog or a wxPanel, or indeed almost any other window.
/**
@class wxBitmapComboBox
- @wxheader{bmpcbox.h}
A combobox that displays bitmap in front of the list items.
It currently only allows using bitmaps of one size, and resizes itself
/**
@class wxBookCtrlBase
- @wxheader{bookctrl.h}
@todo Document this class.
/**
@class wxBrush
- @wxheader{brush.h}
A brush is a drawing tool for filling in areas. It is used for painting
the background of rectangles, ellipses, etc. It has a colour and a style.
/**
@class wxBrushList
- @wxheader{gdicmn.h}
A brush list is a list containing all brushes which have been created.
/**
@class wxMemoryBuffer
- @wxheader{buffer.h}
A @b wxMemoryBuffer is a useful data structure for storing arbitrary sized
blocks of memory. wxMemoryBuffer guarantees deletion of the memory block when
/**
@class wxBusyInfo
- @wxheader{busyinfo.h}
This class makes it easy to tell your user that the program is temporarily busy.
Just create a wxBusyInfo object on the stack, and within the current scope,
/**
@class wxButton
- @wxheader{button.h}
A button is a control that contains a text string, and is one of the most
common elements of a GUI.
/**
@class wxCalendarEvent
- @wxheader{calctrl.h}
The wxCalendarEvent class is used together with wxCalendarCtrl.
/**
@class wxCalendarDateAttr
- @wxheader{calctrl.h}
wxCalendarDateAttr is a custom attributes for a calendar date. The objects
of this class are used with wxCalendarCtrl.
/**
@class wxCalendarCtrl
- @wxheader{calctrl.h}
The calendar control allows the user to pick a date. The user can move the
current selection using the keyboard and select the date (generating
/**
@class wxCaret
- @wxheader{caret.h}
A caret is a blinking cursor showing the position where the typed text will
appear. Text controls usually have their own caret but wxCaret provides a
/**
@class wxCheckBox
- @wxheader{checkbox.h}
A checkbox is a labelled box which by default is either on (checkmark is
visible) or off (no checkmark). Optionally (when the wxCHK_3STATE style
/**
@class wxCheckListBox
- @wxheader{checklst.h}
A wxCheckListBox is like a wxListBox, but allows items to be checked or
unchecked.
/**
@class wxMultiChoiceDialog
- @wxheader{choicdlg.h}
This class represents a dialog that shows a list of strings, and allows the
user to select one or more.
/**
@class wxSingleChoiceDialog
- @wxheader{choicdlg.h}
This class represents a dialog that shows a list of strings, and allows the
user to select one. Double-clicking on a list item is equivalent to
/**
@class wxChoice
- @wxheader{choice.h}
A choice item is used to select one of a list of strings. Unlike a
wxListBox, only the selection is visible until the user pulls down the
/**
@class wxChoicebook
- @wxheader{choicebk.h}
wxChoicebook is a class similar to wxNotebook, but uses a wxChoice control
to show the labels instead of the tabs.
/**
@class wxClipboard
- @wxheader{clipbrd.h}
A class for manipulating the clipboard.
/**
@class wxClientDataContainer
- @wxheader{clntdata.h}
This class is a mixin that provides storage and management of "client
data." This data can either be of type void - in which case the data
/**
@class wxClientData
- @wxheader{clntdata.h}
All classes deriving from wxEvtHandler (such as all controls and wxApp) can
hold arbitrary data which is here referred to as "client data". This is
/**
@class wxStringClientData
- @wxheader{clntdata.h}
Predefined client data class for holding a string.
/**
@class wxColourPickerCtrl
- @wxheader{clrpicker.h}
This control allows the user to select a colour. The generic implementation
is a button which brings up a wxColourDialog when clicked. Native
/**
@class wxColourPickerEvent
- @wxheader{clrpicker.h}
This event class is used for the events generated by wxColourPickerCtrl.
/**
@class wxCmdLineParser
- @wxheader{cmdline.h}
wxCmdLineParser is a class for parsing the command line.
/**
@class wxCommand
- @wxheader{cmdproc.h}
wxCommand is a base class for modelling an application command, which is an
action usually performed by selecting a menu item, pressing a toolbar
/**
@class wxCommandProcessor
- @wxheader{cmdproc.h}
wxCommandProcessor is a class that maintains a history of wxCommands, with
undo/redo functionality built-in. Derive a new class from this if you want
/**
@class wxFontData
- @wxheader{cmndata.h}
This class holds a variety of information related to font dialogs.
/**
@class wxPageSetupDialogData
- @wxheader{cmndata.h}
This class holds a variety of information related to wxPageSetupDialog.
/**
@class wxColourData
- @wxheader{cmndata.h}
This class holds a variety of information related to colour dialogs.
/**
@class wxPrintData
- @wxheader{cmndata.h}
This class holds a variety of information related to printers and printer
device contexts. This class is used to create a wxPrinterDC and a
/**
@class wxPrintDialogData
- @wxheader{cmndata.h}
This class holds information related to the visual characteristics of
wxPrintDialog. It contains a wxPrintData object with underlying printing
/**
@class wxCollapsiblePaneEvent
- @wxheader{collpane.h}
This event class is used for the events generated by wxCollapsiblePane.
/**
@class wxCollapsiblePane
- @wxheader{collpane.h}
A collapsible pane is a container with an embedded button-like control
which can be used by the user to collapse or expand the pane's contents.
/**
@class wxColourDialog
- @wxheader{colordlg.h}
This class represents the colour chooser dialog.
/**
@class wxColour
- @wxheader{colour.h}
A colour is an object representing a combination of Red, Green, and Blue
(RGB) intensity values, and is used to determine drawing colours. See the
/**
@class wxComboPopup
- @wxheader{combo.h}
In order to use a custom popup with wxComboCtrl, an interface class must be
derived from wxComboPopup.
/**
@class wxComboCtrl
- @wxheader{combo.h}
A combo control is a generic combobox that allows totally custom popup. In
addition it has other customization features. For instance, position and
/**
@class wxComboBox
- @wxheader{combobox.h}
A combobox is like a combination of an edit control and a listbox. It can
be displayed as static list with editable or read-only text field; or a
/**
@class wxConfigBase
- @wxheader{config.h}
wxConfigBase defines the basic interface of all config classes. It can not
be used by itself (it is an abstract base class) and you will always use
/**
@class wxControl
- @wxheader{control.h}
This is the base class for a control or "widget".
/**
@class wxConvAuto
- @wxheader{convauto.h}
This class implements a Unicode to/from multibyte converter capable of
automatically recognizing the encoding of the multibyte text on input. The
/**
@class wxHelpProvider
- @wxheader{cshelp.h}
wxHelpProvider is an abstract class used by a program implementing
context-sensitive help to show the help text for the given window.
/**
@class wxHelpControllerHelpProvider
- @wxheader{cshelp.h}
wxHelpControllerHelpProvider is an implementation of wxHelpProvider which
supports both context identifiers and plain text help strings. If the help
/**
@class wxContextHelp
- @wxheader{cshelp.h}
This class changes the cursor to a query and puts the application into a
'context-sensitive help mode'. When the user left-clicks on a window
/**
@class wxContextHelpButton
- @wxheader{cshelp.h}
Instances of this class may be used to add a question mark button that when
pressed, puts the application into context-help mode. It does this by
/**
@class wxSimpleHelpProvider
- @wxheader{cshelp.h}
wxSimpleHelpProvider is an implementation of wxHelpProvider which supports
only plain text help strings, and shows the string associated with the
/**
@class wxItemContainerImmutable
- @wxheader{ctrlsub.h}
wxItemContainer defines an interface which is implemented by all controls
which have string subitems each of which may be selected.
/**
@class wxItemContainer
- @wxheader{ctrlsub.h}
This class is an abstract base class for some wxWidgets controls which
contain several items such as wxListBox, wxCheckListBox, wxComboBox or
/**
@class wxControlWithItems
- @wxheader{ctrlsub.h}
This is convenience class that derives from both wxControl and
wxItemContainer. It is used as basis for some wxWidgets controls
/**
@class wxCursor
- @wxheader{cursor.h}
A cursor is a small bitmap usually used for denoting where the mouse
pointer is, with a picture that might indicate the interpretation of a
/**
@class wxCustomDataObject
- @wxheader{dataobj.h}
wxCustomDataObject is a specialization of wxDataObjectSimple for some
application-specific data in arbitrary (either custom or one of the
/**
@class wxDataObjectComposite
- @wxheader{dataobj.h}
wxDataObjectComposite is the simplest wxDataObject derivation which may be
used to support multiple formats. It contains several wxDataObjectSimple
/**
@class wxDataObjectSimple
- @wxheader{dataobj.h}
This is the simplest possible implementation of the wxDataObject class. The
data object of (a class derived from) this class only supports one format,
/**
@class wxBitmapDataObject
- @wxheader{dataobj.h}
wxBitmapDataObject is a specialization of wxDataObject for bitmap data. It
can be used without change to paste data into the wxClipboard or a
/**
@class wxDataFormat
- @wxheader{dataobj.h}
A wxDataFormat is an encapsulation of a platform-specific format handle
which is used by the system for the clipboard and drag and drop operations.
/**
@class wxURLDataObject
- @wxheader{dataobj.h}
wxURLDataObject is a wxDataObject containing an URL and can be used e.g.
when you need to put an URL on or retrieve it from the clipboard:
/**
@class wxDataObject
- @wxheader{dataobj.h}
A wxDataObject represents data that can be copied to or from the clipboard,
or dragged and dropped. The important thing about wxDataObject is that this
/**
@class wxTextDataObject
- @wxheader{dataobj.h}
wxTextDataObject is a specialization of wxDataObject for text data. It can
be used without change to paste data into the wxClipboard or a
/**
@class wxFileDataObject
- @wxheader{dataobj.h}
wxFileDataObject is a specialization of wxDataObject for file names. The
program works with it just as if it were a list of absolute file names, but
/**
@class wxDataViewIconText
- @wxheader{dataview.h}
wxDataViewIconText is used by
wxDataViewIconTextRenderer
/**
@class wxDataViewEvent
- @wxheader{dataview.h}
wxDataViewEvent - the event class for the wxDataViewCtrl notifications
/**
@class wxDataViewModel
- @wxheader{dataview.h}
wxDataViewModel is the base class for all data model to be
displayed by a wxDataViewCtrl.
/**
@class wxDataViewIndexListModel
- @wxheader{dataview.h}
wxDataViewIndexListModel is a specialized data model which lets
you address an item by its position (row) rather than its
/**
@class wxDataViewVirtualListModel
- @wxheader{dataview.h}
wxDataViewVirtualListModel is a specialized data model which lets
you address an item by its position (row) rather than its
/**
@class wxDataViewItemAttr
- @wxheader{dataview.h}
This class is used to indicate to a wxDataViewCtrl
that a certain Item() has extra font attributes
/**
@class wxDataViewItem
- @wxheader{dataview.h}
wxDataViewItem is a small opaque class that represents an
item in a wxDataViewCtrl in a
/**
@class wxDataViewCtrl
- @wxheader{dataview.h}
wxDataViewCtrl is a control to display data either
in a tree like fashion or in a tabular form or both.
/**
@class wxDataViewModelNotifier
- @wxheader{dataview.h}
A wxDataViewModelNotifier instance is owned by a
wxDataViewModel
/**
@class wxDataViewRenderer
- @wxheader{dataview.h}
This class is used by wxDataViewCtrl to render the individual cells.
One instance of a renderer class is owned by a wxDataViewColumn. There
/**
@class wxDataViewTextRenderer
- @wxheader{dataview.h}
wxDataViewTextRenderer is used for rendering text. It supports
in-place editing if desired.
/**
@class wxDataViewIconTextRenderer
- @wxheader{dataview.h}
The wxDataViewIconTextRenderer class is used to display text with
a small icon next to it as it is typically done in a file manager.
/**
@class wxDataViewProgressRenderer
- @wxheader{dataview.h}
wxDataViewProgressRenderer
/**
@class wxDataViewSpinRenderer
- @wxheader{dataview.h}
This is a specialized renderer for rendering integer values. It
supports modifying the values in-place by using a wxSpinCtrl.
/**
@class wxDataViewToggleRenderer
- @wxheader{dataview.h}
wxDataViewToggleRenderer
/**
@class wxDataViewDateRenderer
- @wxheader{dataview.h}
wxDataViewDateRenderer
/**
@class wxDataViewTextRendererAttr
- @wxheader{dataview.h}
The same as wxDataViewTextRenderer but with
support for font attributes. Font attributes are currently only supported
/**
@class wxDataViewCustomRenderer
- @wxheader{dataview.h}
You need to derive a new class from wxDataViewCustomRenderer in
order to write a new renderer. You need to override at least
/**
@class wxDataViewBitmapRenderer
- @wxheader{dataview.h}
wxDataViewBitmapRenderer
/**
@class wxDataViewColumn
- @wxheader{dataview.h}
This class represents a column in a wxDataViewCtrl.
One wxDataViewColumn is bound to one column in the data model,
/**
@class wxDataViewTreeCtrl
- @wxheader{dataview.h}
This class is a wxDataViewCtrl which internally
uses a wxDataViewTreeStore and forwards
/**
@class wxDataViewTreeStore
- @wxheader{dataview.h}
wxDataViewTreeStore is a specialised wxDataViewModel
for displaying simple trees very much like wxTreeCtrl
/**
@class wxDatePickerCtrl
- @wxheader{datectrl.h}
This control allows the user to select a date. Unlike wxCalendarCtrl, which
is a relatively big control, wxDatePickerCtrl is implemented as a small
/**
@class wxDateEvent
- @wxheader{dateevt.h}
This event class holds information about a date change and is used together
with wxDatePickerCtrl. It also serves as a base class
/**
@class wxDateTime
- @wxheader{datetime.h}
wxDateTime class represents an absolute moment in the time.
/**
@class wxDateTimeWorkDays
- @wxheader{datetime.h}
@todo Write wxDateTimeWorkDays documentation.
/**
@class wxDateSpan
- @wxheader{datetime.h}
This class is a "logical time span" and is useful for implementing program
logic for such things as "add one month to the date" which, in general,
/**
@class wxTimeSpan
- @wxheader{datetime.h}
wxTimeSpan class represents a time interval.
/**
@class wxDateTimeHolidayAuthority
- @wxheader{datetime.h}
@todo Write wxDateTimeHolidayAuthority documentation.
/**
@class wxDataOutputStream
- @wxheader{datstrm.h}
This class provides functions that write binary data types in a portable
way. Data can be written in either big-endian or little-endian format,
/**
@class wxDataInputStream
- @wxheader{datstrm.h}
This class provides functions that read binary data types in a portable
way. Data can be read in either big-endian or little-endian format,
/**
@class wxDC
- @wxheader{dc.h}
A wxDC is a @e "device context" onto which graphics and text can be drawn.
It is intended to represent different output devices and offers a common
/**
@class wxDCClipper
- @wxheader{dc.h}
wxDCClipper is a small helper class for setting a clipping region on a wxDC
and unsetting it automatically. An object of wxDCClipper class is typically
/**
@class wxBufferedDC
- @wxheader{dcbuffer.h}
This class provides a simple way to avoid flicker: when drawing on it,
everything is in fact first drawn on an in-memory buffer (a wxBitmap) and
/**
@class wxAutoBufferedPaintDC
- @wxheader{dcbuffer.h}
This wxDC derivative can be used inside of an @c EVT_PAINT() event handler
to achieve double-buffered drawing. Just use this class instead of
/**
@class wxBufferedPaintDC
- @wxheader{dcbuffer.h}
This is a subclass of wxBufferedDC which can be used inside of an
@c EVT_PAINT() event handler to achieve double-buffered drawing. Just use
/**
@class wxPaintDC
- @wxheader{dcclient.h}
A wxPaintDC must be constructed if an application wishes to paint on the
client area of a window from within an EVT_PAINT() event handler. This
/**
@class wxClientDC
- @wxheader{dcclient.h}
A wxClientDC must be constructed if an application wishes to paint on the
client area of a window from outside an EVT_PAINT() handler. This should
/**
@class wxWindowDC
- @wxheader{dcclient.h}
A wxWindowDC must be constructed if an application wishes to paint on the
whole area of a window (client and decorations). This should normally be
/**
@class wxGCDC
- @wxheader{dcgraph.h}
wxGCDC is a device context that draws on a wxGraphicsContext.
/**
@class wxMemoryDC
- @wxheader{dcmemory.h}
A memory device context provides a means to draw graphics onto a bitmap.
When drawing in to a mono-bitmap, using @c wxWHITE, @c wxWHITE_PEN and
/**
@class wxMirrorDC
- @wxheader{dcmirror.h}
wxMirrorDC is a simple wrapper class which is always associated with a real
wxDC object and either forwards all of its operations to it without changes
/**
@class wxPrinterDC
- @wxheader{dcprint.h}
A printer device context is specific to MSW and Mac, and allows access to
any printer with a Windows or Macintosh driver. See wxDC for further
/**
@class wxPostScriptDC
- @wxheader{dcps.h}
This defines the wxWidgets Encapsulated PostScript device context, which
can write PostScript files on any platform. See wxDC for descriptions of
/**
@class wxScreenDC
- @wxheader{dcscreen.h}
A wxScreenDC can be used to paint on the screen. This should normally be
constructed as a temporary stack object; don't store a wxScreenDC object.
/**
@class wxSVGFileDC
- @wxheader{dcsvg.h}
A wxSVGFileDC is a device context onto which graphics and text can be
drawn, and the output produced as a vector file, in SVG format (see the W3C
/**
@class wxDDEConnection
- @wxheader{dde.h}
A wxDDEConnection object represents the connection between a client and a
server. It can be created by making a connection using a wxDDEClient
/**
@class wxDDEClient
- @wxheader{dde.h}
A wxDDEClient object represents the client part of a client-server DDE
(Dynamic Data Exchange) conversation.
/**
@class wxDDEServer
- @wxheader{dde.h}
A wxDDEServer object represents the server part of a client-server DDE
(Dynamic Data Exchange) conversation.
/**
@class wxDebugReportPreview
- @wxheader{debugrpt.h}
This class presents the debug report to the user and allows him to veto
report entirely or remove some parts of it. Although not mandatory, using
/**
@class wxDebugReportCompress
- @wxheader{debugrpt.h}
wxDebugReportCompress is a wxDebugReport which compresses all the files in
this debug report into a single ZIP file in its wxDebugReport::Process()
/**
@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
/**
@class wxDebugReportPreviewStd
- @wxheader{debugrpt.h}
wxDebugReportPreviewStd is a standard debug report preview window. It
displays a dialog allowing the user to examine the contents of a debug
/**
@class wxDebugReportUpload
- @wxheader{debugrpt.h}
This class is used to upload a compressed file using HTTP POST request. As
this class derives from wxDebugReportCompress, before upload the report is
/**
@class wxDialog
- @wxheader{dialog.h}
A dialog box is a window with a title bar and sometimes a system menu,
which can be moved around the screen. It can contain controls and other
/**
@class wxDialogLayoutAdapter
- @wxheader{dialog.h}
This abstract class is the base for classes that help wxWidgets peform
run-time layout adaptation of dialogs. Principally, this is to cater for
/**
@class wxDialUpManager
- @wxheader{dialup.h}
This class encapsulates functions dealing with verifying the connection
status of the workstation (connected to the Internet via a direct
/**
@class wxDialUpEvent
- @wxheader{dialup.h}
This is the event class for the dialup events sent by wxDialUpManager.
/**
@class wxDirTraverser
- @wxheader{dir.h}
wxDirTraverser is an abstract interface which must be implemented by
objects passed to wxDir::Traverse() function.
/**
@class wxDir
- @wxheader{dir.h}
wxDir is a portable equivalent of Unix open/read/closedir functions which
allow enumerating of the files in a directory. wxDir allows to enumerate
/**
@class wxGenericDirCtrl
- @wxheader{dirctrl.h}
This control can be used to place a directory listing (with optional
files) on an arbitrary window.
/**
@class wxDirDialog
- @wxheader{dirdlg.h}
This class represents the directory chooser dialog.
/**
@class wxDisplay
- @wxheader{display.h}
Determines the sizes and locations of displays connected to the system.
/**
@class wxTextDropTarget
- @wxheader{dnd.h}
A predefined drop target for dealing with text data.
/**
@class wxDropTarget
- @wxheader{dnd.h}
This class represents a target for a drag and drop operation. A
wxDataObject can be associated with it and by default, this object will be
/**
@class wxDropSource
- @wxheader{dnd.h}
This class represents a source for a drag and drop operation.
/**
@class wxFileDropTarget
- @wxheader{dnd.h}
This is a drop target which accepts files (dragged from File Manager or
Explorer).
/**
@class wxDocMDIParentFrame
- @wxheader{docmdi.h}
The wxDocMDIParentFrame class provides a default top-level frame for
applications using the document/view framework. This class can only be used
/**
@class wxDocMDIChildFrame
- @wxheader{docmdi.h}
The wxDocMDIChildFrame class provides a default frame for displaying
documents on separate windows. This class can only be used for MDI child
/**
@class wxDocTemplate
- @wxheader{docview.h}
The wxDocTemplate class is used to model the relationship between a
document class and a view class.
/**
@class wxDocManager
- @wxheader{docview.h}
The wxDocManager class is part of the document/view framework supported by
wxWidgets, and cooperates with the wxView, wxDocument and wxDocTemplate
/**
@class wxView
- @wxheader{docview.h}
The view class can be used to model the viewing and editing component of
an application's file-based data. It is part of the document/view framework
/**
@class wxDocChildFrame
- @wxheader{docview.h}
The wxDocChildFrame class provides a default frame for displaying documents
on separate windows. This class can only be used for SDI (not MDI) child
/**
@class wxDocParentFrame
- @wxheader{docview.h}
The wxDocParentFrame class provides a default top-level frame for
applications using the document/view framework. This class can only be used
/**
@class wxDocument
- @wxheader{docview.h}
The document class can be used to model an application's file-based data.
It is part of the document/view framework supported by wxWidgets, and
/**
@class wxFileHistory
- @wxheader{docview.h}
The wxFileHistory encapsulates a user interface convenience, the list of
most recently visited files as shown on a menu (usually the File menu).
/**
@class wxDragImage
- @wxheader{dragimag.h}
This class is used when you wish to drag an object on the screen, and a
simple cursor is not enough.
/////////////////////////////////////////////////////////////////////////////
/**
- @wxheader{dynarray.h}
This section describes the so called @e "dynamic arrays". This is a C
array-like type safe data structure i.e. the member access time is constant
/**
@class wxDynamicLibraryDetails
- @wxheader{dynlib.h}
This class is used for the objects returned by the
wxDynamicLibrary::ListLoaded() method and contains the information about a
/**
@class wxDynamicLibrary
- @wxheader{dynlib.h}
wxDynamicLibrary is a class representing dynamically loadable library
(Windows DLL, shared library under Unix etc.). Just create an object of
/**
@class wxEditableListBox
- @wxheader{editlbox.h}
An editable listbox is composite control that lets the user easily enter,
delete and reorder a list of strings.
/**
@class wxEncodingConverter
- @wxheader{encconv.h}
This class is capable of converting strings between two 8-bit encodings/charsets.
It can also convert from/to Unicode (but only if you compiled wxWidgets
/**
@class wxEvent
- @wxheader{event.h}
An event is a structure holding information about an event passed to a
callback or member function.
/**
@class wxEventBlocker
- @wxheader{event.h}
This class is a special event handler which allows to discard
any event (or a set of event types) directed to a specific window.
/**
@class wxEvtHandler
- @wxheader{event.h}
A class that can handle events from the windowing system.
wxWindow (and therefore all window classes) are derived from this class.
/**
@class wxKeyEvent
- @wxheader{event.h}
This event class contains information about keypress (character) events.
/**
@class wxJoystickEvent
- @wxheader{event.h}
This event class contains information about joystick events, particularly
events received by windows.
/**
@class wxScrollWinEvent
- @wxheader{event.h}
A scroll event holds information about events sent from scrolling windows.
/**
@class wxSysColourChangedEvent
- @wxheader{event.h}
This class is used for system colour change events, which are generated
when the user changes the colour settings using the control panel.
/**
@class wxWindowCreateEvent
- @wxheader{event.h}
This event is sent just after the actual window associated with a wxWindow
object has been created.
/**
@class wxPaintEvent
- @wxheader{event.h}
A paint event is sent when a window's contents needs to be repainted.
/**
@class wxMaximizeEvent
- @wxheader{event.h}
An event being sent when a top level window is maximized. Notice that it is
not sent when the window is restored to its original size after it had been
/**
@class wxUpdateUIEvent
- @wxheader{event.h}
This class is used for pseudo-events which are called by wxWidgets
to give an application the chance to update various user interface elements.
/**
@class wxClipboardTextEvent
- @wxheader{event.h}
This class represents the events generated by a control (typically a
wxTextCtrl but other windows can generate these events as well) when its
/**
@class wxMouseEvent
- @wxheader{event.h}
This event class contains information about the events generated by the mouse:
they include mouse buttons press and release events and mouse move events.
/**
@class wxDropFilesEvent
- @wxheader{event.h}
This class is used for drop files events, that is, when files have been dropped
onto the window. This functionality is currently only available under Windows.
/**
@class wxCommandEvent
- @wxheader{event.h}
This event class contains information about command events, which originate
from a variety of simple controls.
/**
@class wxActivateEvent
- @wxheader{event.h}
An activate event is sent when a window or application is being activated
or deactivated.
/**
@class wxContextMenuEvent
- @wxheader{event.h}
This class is used for context menu events, sent to give
the application a chance to show a context (popup) menu.
/**
@class wxEraseEvent
- @wxheader{event.h}
An erase event is sent when a window's background needs to be repainted.
/**
@class wxFocusEvent
- @wxheader{event.h}
A focus event is sent when a window's focus changes. The window losing focus
receives a "kill focus" event while the window gaining it gets a "set focus" one.
/**
@class wxChildFocusEvent
- @wxheader{event.h}
A child focus event is sent to a (parent-)window when one of its child windows
gains focus, so that the window could restore the focus back to its corresponding
/**
@class wxMouseCaptureLostEvent
- @wxheader{event.h}
An mouse capture lost event is sent to a window that obtained mouse capture,
which was subsequently loss due to "external" event, for example when a dialog
/**
@class wxNotifyEvent
- @wxheader{event.h}
This class is not used by the event handlers by itself, but is a base class
for other event classes (such as wxNotebookEvent).
/**
@class wxHelpEvent
- @wxheader{event.h}
A help event is sent when the user has requested context-sensitive help.
This can either be caused by the application requesting context-sensitive help mode
/**
@class wxScrollEvent
- @wxheader{event.h}
A scroll event holds information about events sent from stand-alone
scrollbars (see wxScrollBar) and sliders (see wxSlider).
/**
@class wxIdleEvent
- @wxheader{event.h}
This class is used for idle events, which are generated when the system becomes
idle. Note that, unless you do something specifically, the idle events are not
/**
@class wxInitDialogEvent
- @wxheader{event.h}
A wxInitDialogEvent is sent as a dialog or panel is being initialised.
Handlers for this event can transfer data to the window.
/**
@class wxWindowDestroyEvent
- @wxheader{event.h}
This event is sent from the wxWindow destructor wxWindow::~wxWindow() when a
window is destroyed.
/**
@class wxNavigationKeyEvent
- @wxheader{event.h}
This event class contains information about navigation events,
generated by navigation keys such as tab and page down.
/**
@class wxMouseCaptureChangedEvent
- @wxheader{event.h}
An mouse capture changed event is sent to a window that loses its
mouse capture. This is called even if wxWindow::ReleaseCapture
/**
@class wxCloseEvent
- @wxheader{event.h}
This event class contains information about window and session close events.
/**
@class wxMenuEvent
- @wxheader{event.h}
This class is used for a variety of menu-related events. Note that
these do not include menu command events, which are
/**
@class wxShowEvent
- @wxheader{event.h}
An event being sent when the window is shown or hidden.
/**
@class wxIconizeEvent
- @wxheader{event.h}
An event being sent when the frame is iconized (minimized) or restored.
/**
@class wxMoveEvent
- @wxheader{event.h}
A move event holds information about move change events.
/**
@class wxSizeEvent
- @wxheader{event.h}
A size event holds information about size change events.
/**
@class wxSetCursorEvent
- @wxheader{event.h}
A SetCursorEvent is generated when the mouse cursor is about to be set as a
result of mouse motion.
/**
@class wxFindDialogEvent
- @wxheader{fdrepdlg.h}
wxFindReplaceDialog events
/**
@class wxFindReplaceData
- @wxheader{fdrepdlg.h}
wxFindReplaceData holds the data for wxFindReplaceDialog.
/**
@class wxFindReplaceDialog
- @wxheader{fdrepdlg.h}
wxFindReplaceDialog is a standard modeless dialog which is used to allow the
user to search for some text (and possibly replace it with something else).
/**
@class wxFFile
- @wxheader{ffile.h}
wxFFile implements buffered file I/O.
/**
@class wxTempFile
- @wxheader{file.h}
wxTempFile provides a relatively safe way to replace the contents of the
existing file. The name is explained by the fact that it may be also used as
/**
@class wxFile
- @wxheader{file.h}
A wxFile performs raw file I/O. This is a very small class designed to
minimize the overhead of using it - in fact, there is hardly any overhead at
/**
@class wxFileConfig
- @wxheader{fileconf.h}
wxFileConfig implements wxConfigBase interface for
storing and retrieving configuration information using plain text files. The
/**
@class wxFileCtrl
- @wxheader{filectrl.h}
This control allows the user to select a file.
/**
@class wxFileCtrlEvent
- @wxheader{filectrl.h}
A file control event holds information about events associated with
wxFileCtrl objects.
/**
@class wxFileDialog
- @wxheader{filedlg.h}
This class represents the file chooser dialog.
/**
@class wxPathList
- @wxheader{filefn.h}
The path list is a convenient way of storing a number of directories, and
when presented with a filename without a directory, searching for an
/**
@class wxFileName
- @wxheader{filename.h}
wxFileName encapsulates a file name. This class serves two purposes: first, it
provides the functions to split the file names into components and to recombine
/**
@class wxFilePickerCtrl
- @wxheader{filepicker.h}
This control allows the user to select a file. The generic implementation is
a button which brings up a wxFileDialog when clicked. Native implementation
/**
@class wxDirPickerCtrl
- @wxheader{filepicker.h}
This control allows the user to select a directory. The generic implementation
is
/**
@class wxFileDirPickerEvent
- @wxheader{filepicker.h}
This event class is used for the events generated by
wxFilePickerCtrl and by wxDirPickerCtrl.
/**
@class wxFileSystem
- @wxheader{filesys.h}
This class provides an interface for opening files on different file systems.
It can handle absolute and/or local filenames.
/**
@class wxFSFile
- @wxheader{filesys.h}
This class represents a single file opened by wxFileSystem.
It provides more information than wxWindow's input stream
/**
@class wxFileSystemHandler
- @wxheader{filesys.h}
Classes derived from wxFileSystemHandler are used to access virtual file systems.
/**
@class wxFont
- @wxheader{font.h}
A font is an object which determines the appearance of text. Fonts are
used for drawing text to a device context, and setting the appearance of
/**
@class wxFontList
- @wxheader{gdicmn.h}
A font list is a list containing all fonts which have been created. There
is only one instance of this class: @b wxTheFontList. Use this object to search
/**
@class wxFontDialog
- @wxheader{fontdlg.h}
This class represents the font chooser dialog.
/**
@class wxFontEnumerator
- @wxheader{fontenum.h}
wxFontEnumerator enumerates either all available fonts on the system or only
the ones with given attributes - either only fixed-width (suited for use in
/**
@class wxFontMapper
- @wxheader{fontmap.h}
wxFontMapper manages user-definable correspondence between logical font
names and the fonts present on the machine.
/**
@class wxFontPickerCtrl
- @wxheader{fontpicker.h}
This control allows the user to select a font. The generic implementation is
a button which brings up a wxFontDialog when clicked. Native implementation
/**
@class wxFontPickerEvent
- @wxheader{fontpicker.h}
This event class is used for the events generated by
wxFontPickerCtrl.
/**
@class wxFrame
- @wxheader{frame.h}
A frame is a window whose size and position can (usually) be changed by the user.
/**
@class wxMemoryFSHandler
- @wxheader{fs_mem.h}
This wxFileSystem handler can store arbitrary data in memory stream and make
them accessible via an URL.
/**
@class wxGauge
- @wxheader{gauge.h}
A gauge is a horizontal or vertical bar which shows a quantity (often
time).
/**
@class wxGBPosition
- @wxheader{gbsizer.h}
This class represents the position of an item in a virtual grid of rows and
columns managed by a wxGridBagSizer.
/**
@class wxGridBagSizer
- @wxheader{gbsizer.h}
A wxSizer that can lay out items in a virtual grid like a wxFlexGridSizer
but in this case explicit positioning of the items is allowed using
/**
@class wxGBSizerItem
- @wxheader{gbsizer.h}
The wxGBSizerItem class is used by the wxGridBagSizer for tracking the
items in the sizer. It adds grid position and spanning information to the
/**
@class wxGBSpan
- @wxheader{gbsizer.h}
This class is used to hold the row and column spanning attributes of items
in a wxGridBagSizer.
/**
@class wxRealPoint
- @wxheader{gdicmn.h}
A wxRealPoint is a useful data structure for graphics operations.
/**
@class wxRect
- @wxheader{gdicmn.h}
A class for manipulating rectangles.
/**
@class wxPoint
- @wxheader{gdicmn.h}
A wxPoint is a useful data structure for graphics operations.
/**
@class wxColourDatabase
- @wxheader{gdicmn.h}
wxWidgets maintains a database of standard RGB colours for a predefined
set of named colours. The application may add to this set if desired by
/**
@class wxSize
- @wxheader{gdicmn.h}
A wxSize is a useful data structure for graphics operations. It simply
contains integer @e width and @e height members.
/**
@class wxGDIObject
- @wxheader{gdiobj.h}
This class allows platforms to implement functionality to optimise GDI objects,
such
/**
@class wxExtHelpController
- @wxheader{help.h}
This class implements help via an external browser.
It requires the name of a directory containing the documentation
/**
@class wxGLContext
- @wxheader{glcanvas.h}
An instance of a wxGLContext represents the state of an OpenGL state machine
and the connection between OpenGL and the system.
/**
@class wxGLCanvas
- @wxheader{glcanvas.h}
wxGLCanvas is a class for displaying OpenGL graphics. It is always used in
conjunction with wxGLContext as the context can only be
/**
@class wxGraphicsPath
- @wxheader{graphics.h}
A wxGraphicsPath is a native representation of an geometric path. The contents
are specific an private to the respective renderer. Instances are ref counted and can
/**
@class wxGraphicsObject
- @wxheader{graphics.h}
This class is the superclass of native graphics objects like pens etc. It
allows reference counting. Not instantiated by user code.
/**
@class wxGraphicsContext
- @wxheader{graphics.h}
A wxGraphicsContext instance is the object that is drawn upon. It is created by
a renderer using wxGraphicsRenderer::CreateContext(). This can be either directly
/**
@class wxGraphicsRenderer
- @wxheader{graphics.h}
A wxGraphicsRenderer is the instance corresponding to the rendering engine
used. There may be multiple instances on a system, if there are different
/**
@class wxGraphicsBrush
- @wxheader{graphics.h}
@library{wxcore}
/**
@class wxGraphicsFont
- @wxheader{graphics.h}
@library{wxcore}
/**
@class wxGraphicsPen
- @wxheader{graphics.h}
@library{wxcore}
/**
@class wxGraphicsMatrix
- @wxheader{graphics.h}
A wxGraphicsMatrix is a native representation of an affine matrix. The contents
are specific and private to the respective renderer. Instances are ref counted and can therefore be assigned as usual. The only way to get a valid instance is via a CreateMatrix call on the graphics context or the renderer instance.
/**
@class wxGridCellFloatRenderer
- @wxheader{grid.h}
This class may be used to format floating point data in a cell.
/**
@class wxGridTableBase
- @wxheader{grid.h}
Grid table classes.
/**
@class wxGridCellEditor
- @wxheader{grid.h}
This class is responsible for providing and manipulating
the in-place edit controls for the grid. Instances of wxGridCellEditor
/**
@class wxGridCellTextEditor
- @wxheader{grid.h}
The editor for string/text data.
/**
@class wxGridCellStringRenderer
- @wxheader{grid.h}
This class may be used to format string data in a cell; it is the default
for string cells.
/**
@class wxGridCellChoiceEditor
- @wxheader{grid.h}
The editor for string data allowing to choose from a list of strings.
/**
@class wxGridEditorCreatedEvent
- @wxheader{grid.h}
@library{wxadv}
/**
@class wxGridRangeSelectEvent
- @wxheader{grid.h}
@library{wxadv}
/**
@class wxGridCellRenderer
- @wxheader{grid.h}
This class is responsible for actually drawing the cell
in the grid. You may pass it to the wxGridCellAttr (below) to change the
/**
@class wxGridCellNumberEditor
- @wxheader{grid.h}
The editor for numeric integer data.
/**
@class wxGridSizeEvent
- @wxheader{grid.h}
This event class contains information about a row/column resize event.
/**
@class wxGridCellNumberRenderer
- @wxheader{grid.h}
This class may be used to format integer data in a cell.
/**
@class wxGridCellAttr
- @wxheader{grid.h}
This class can be used to alter the cells' appearance in
the grid by changing their colour/font/... from default. An object of this
/**
@class wxGridCellBoolRenderer
- @wxheader{grid.h}
This class may be used to format boolean data in a cell.
for string cells.
/**
@class wxGridEvent
- @wxheader{grid.h}
This event class contains information about various grid events.
/**
@class wxGridCellFloatEditor
- @wxheader{grid.h}
The editor for floating point numbers data.
/**
@class wxGrid
- @wxheader{grid.h}
wxGrid and its related classes are used for displaying and editing tabular
data. They provide a rich set of features for display, editing, and
/**
@class wxGridCellBoolEditor
- @wxheader{grid.h}
The editor for boolean data.
/**
@class wxGridUpdateLocker
- @wxheader{grid.h}
This small class can be used to prevent wxGrid from redrawing
during its lifetime by calling wxGrid::BeginBatch
/**
@class wxHashTable
- @wxheader{hash.h}
@b Please note that this class is retained for backward compatibility
reasons; you should use wxHashMap.
/**
@class wxHashMap
- @wxheader{hashmap.h}
This is a simple, type-safe, and reasonably efficient hash map class,
whose interface is a subset of the interface of STL containers. In
/**
@class wxHashSet
- @wxheader{hashset.h}
This is a simple, type-safe, and reasonably efficient hash set class,
whose interface is a subset of the interface of STL containers. In
/**
@class wxHelpController
- @wxheader{help.h}
This is a family of classes by which
applications may invoke a help viewer to provide on-line help.
/**
@class wxHtmlHelpController
- @headerfile helpctrl.h wx/html/helpctrl.h
This help controller provides an easy way of displaying HTML help in your
application (see @e test sample). The help system is based on @b books
/**
@class wxHtmlModalHelp
- @headerfile helpctrl.h wx/html/helpctrl.h
This class uses wxHtmlHelpController
to display help in a modal dialog. This is useful on platforms such as wxMac
/**
@class wxHtmlHelpData
- @headerfile helpdata.h wx/html/helpdata.h
This class is used by wxHtmlHelpController
and wxHtmlHelpFrame to access HTML help items.
/**
@class wxHtmlHelpDialog
- @headerfile helpdlg.h wx/html/helpdlg.h
This class is used by wxHtmlHelpController
to display help.
/**
@class wxHtmlHelpFrame
- @headerfile helpfrm.h wx/html/helpfrm.h
This class is used by wxHtmlHelpController
to display help.
/**
@class wxHtmlHelpWindow
- @headerfile helpwnd.h wx/html/helpwnd.h
This class is used by wxHtmlHelpController
to display help within a frame or dialog, but you can use it yourself to create
/**
@class wxHtmlColourCell
- @headerfile htmlcell.h wx/html/htmlcell.h
This cell changes the colour of either the background or the foreground.
/**
@class wxHtmlWidgetCell
- @headerfile htmlcell.h wx/html/htmlcell.h
wxHtmlWidgetCell is a class that provides a connection between HTML cells and
widgets (an object derived
/**
@class wxHtmlCell
- @headerfile htmlcell.h wx/html/htmlcell.h
Internal data structure. It represents fragments of parsed HTML
page, the so-called @b cell - a word, picture, table, horizontal line and so on.
/**
@class wxHtmlContainerCell
- @headerfile htmlcell.h wx/html/htmlcell.h
The wxHtmlContainerCell class is an implementation of a cell that may
contain more cells in it. It is heavily used in the wxHTML layout algorithm.
/**
@class wxHtmlLinkInfo
- @headerfile htmlcell.h wx/html/htmlcell.h
This class stores all necessary information about hypertext
links (as represented by @c A tag in HTML documents). In
/**
@class wxHtmlFilter
- @headerfile htmlfilt.h wx/html/htmlfilt.h
This class is the parent class of input filters for wxHtmlWindow.
It allows you to read and display files of different file formats.
/**
@class wxHtmlTagHandler
- @headerfile htmlpars.h wx/html/htmlpars.h
@library{wxhtml}
/**
@class wxHtmlParser
- @headerfile htmlpars.h wx/html/htmlpars.h
Classes derived from this handle the @b generic parsing of HTML documents: it
scans
/**
@class wxHtmlTag
- @headerfile htmltag.h wx/html/htmltag.h
This class represents a single HTML tag.
It is used by @ref overview_handlers "tag handlers".
/**
@class wxHtmlWindow
- @headerfile htmlwin.h wx/html/htmlwin.h
wxHtmlWindow is probably the only class you will directly use
unless you want to do something special (like adding new tag
/**
@class wxHtmlLinkEvent
- @headerfile htmlwin.h wx/html/htmlwin.h
This event class is used for the events generated by wxHtmlWindow.
/**
@class wxHtmlCellEvent
- @headerfile htmlwin.h wx/html/htmlwin.h
This event class is used for the events generated by wxHtmlWindow.
/**
@class wxHtmlDCRenderer
- @headerfile htmprint.h wx/html/htmprint.h
This class can render HTML document into a specified area of a DC. You can use
it
/**
@class wxHtmlEasyPrinting
- @headerfile htmprint.h wx/html/htmprint.h
This class provides very simple interface to printing
architecture. It allows you to print HTML documents using
/**
@class wxHtmlPrintout
- @headerfile htmprint.h wx/html/htmprint.h
This class serves as printout class for HTML documents.
/**
@class wxHtmlTagsModule
- @headerfile winpars.h wx/html/winpars.h
This class provides easy way of filling wxHtmlWinParser's table of
tag handlers. It is used almost exclusively together with the set of
/**
@class wxHtmlWinTagHandler
- @headerfile winpars.h wx/html/winpars.h
This is basically wxHtmlTagHandler except that
it is extended with protected member m_WParser pointing to
/**
@class wxHtmlWinParser
- @headerfile winpars.h wx/html/winpars.h
This class is derived from wxHtmlParser and
its main goal is to parse HTML input so that it can be displayed in
/**
@class wxHtmlListBox
- @wxheader{htmllbox.h}
wxHtmlListBox is an implementation of wxVListBox which
shows HTML content in the listbox rows. This is still an abstract base class
/**
@class wxSimpleHtmlListBox
- @wxheader{htmllbox.h}
wxSimpleHtmlListBox is an implementation of wxHtmlListBox which
shows HTML content in the listbox rows.
/**
@class wxHyperlinkEvent
- @wxheader{hyperlink.h}
This event class is used for the events generated by
wxHyperlinkCtrl.
/**
@class wxHyperlinkCtrl
- @wxheader{hyperlink.h}
This class shows a static text element which links to an URL.
Appearance and behaviour is completely customizable. In fact, when the user
/**
@class wxIcon
- @wxheader{icon.h}
An icon is a small rectangular bitmap usually used for denoting a
minimized application. It differs from a wxBitmap in always
/**
@class wxIconBundle
- @wxheader{iconbndl.h}
This class contains multiple copies of an icon in different sizes,
see also wxDialog::SetIcons and
/**
@class wxIconLocation
- @wxheader{iconloc.h}
wxIconLocation is a tiny class describing the location of an (external, i.e.
not embedded into the application resources) icon. For most platforms it simply
/**
@class wxImageHandler
- @wxheader{image.h}
This is the base class for implementing image file loading/saving, and
image creation from data.
/**
@class wxImage
- @wxheader{image.h}
This class encapsulates a platform-independent image. An image can be
created from data, or using wxBitmap::ConvertToImage. An image can be
/**
@class wxImageList
- @wxheader{imaglist.h}
A wxImageList contains a list of images, which are stored in
an unspecified form. Images can have masks for transparent
/**
@class wxLocale
- @wxheader{intl.h}
wxLocale class encapsulates all language-dependent settings and is a
generalization of the C locale concept.
/**
@class wxXLocale
- @wxheader{intl.h}
wxXLocale::wxXLocale
/**
@class wxConnection
- @wxheader{ipc.h}
A wxConnection object represents the connection between a client
and a server. It is created by making a connection using a
/**
@class wxClient
- @wxheader{ipc.h}
A wxClient object represents the client part of a client-server
DDE-like (Dynamic Data Exchange) conversation. The actual
/**
@class wxServer
- @wxheader{ipc.h}
A wxServer object represents the server part of a client-server
DDE-like (Dynamic Data Exchange) conversation. The actual
/**
@class wxConnectionBase
- @wxheader{ipcbase.h}
@todo Document this class.
/**
@class wxJoystick
- @wxheader{joystick.h}
wxJoystick allows an application to control one or more joysticks.
/**
@class wxLayoutAlgorithm
- @wxheader{laywin.h}
wxLayoutAlgorithm implements layout of subwindows in MDI or SDI frames.
It sends a wxCalculateLayoutEvent event
/**
@class wxSashLayoutWindow
- @wxheader{laywin.h}
wxSashLayoutWindow responds to OnCalculateLayout events generated
by wxLayoutAlgorithm. It allows the
/**
@class wxQueryLayoutInfoEvent
- @wxheader{laywin.h}
This event is sent when wxLayoutAlgorithm wishes to get
the size, orientation and alignment of a window. More precisely, the event is
/**
@class wxCalculateLayoutEvent
- @wxheader{laywin.h}
This event is sent by wxLayoutAlgorithm to
calculate the amount of the remaining client area that the window should
/////////////////////////////////////////////////////////////////////////////
/**
- @wxheader{list.h}
The wxList<T> class provides linked list functionality. It has been rewritten
to be type safe and to provide the full API of the STL std::list container and
/**
@class wxNode
- @wxheader{list.h}
wxNodeBase is the node structure used in linked lists (see
wxList) and derived classes. You should never use wxNodeBase
/**
@class wxListbook
- @wxheader{listbook.h}
wxListbook is a class similar to wxNotebook but which
uses a wxListCtrl to show the labels instead of the
/**
@class wxListBox
- @wxheader{listbox.h}
A listbox is used to select one or more of a list of strings. The
strings are displayed in a scrolling box, with the selected string(s)
/**
@class wxListCtrl
- @wxheader{listctrl.h}
A list control presents lists in a number of formats: list view, report view,
icon view and small icon view. In any case, elements are numbered from zero.
/**
@class wxListEvent
- @wxheader{listctrl.h}
A list event holds information about events associated with wxListCtrl objects.
/**
@class wxListItemAttr
- @wxheader{listctrl.h}
Represents the attributes (color, font, ...) of a
wxListCtrl wxListItem.
/**
@class wxListView
- @wxheader{listctrl.h}
This class currently simply presents a simpler to use interface for the
wxListCtrl -- it can be thought of as a @e faade
/**
@class wxListItem
- @wxheader{listctrl.h}
This class stores information about a wxListCtrl item or column.
/**
@class wxLogWindow
- @wxheader{log.h}
This class represents a background log window: to be precise, it collects all
log messages in the log frame which it manages but also passes them on to the
/**
@class wxLogInterposerTemp
- @wxheader{log.h}
A special version of wxLogChain which uses itself as the
new log target. It forwards log messages to the previously installed one in
/**
@class wxLogChain
- @wxheader{log.h}
This simple class allows you to chain log sinks, that is to install a new sink but
keep passing log messages to the old one instead of replacing it completely as
/**
@class wxLogGui
- @wxheader{log.h}
This is the default log target for the GUI wxWidgets applications. It is passed
to wxLog::SetActiveTarget at the program
/**
@class wxLogStream
- @wxheader{log.h}
This class can be used to redirect the log messages to a C++ stream.
/**
@class wxLogStderr
- @wxheader{log.h}
This class can be used to redirect the log messages to a C file stream (not to
be confused with C++ streams). It is the default log target for the non-GUI
/**
@class wxLogBuffer
- @wxheader{log.h}
wxLogBuffer is a very simple implementation of log sink which simply collects
all the logged messages in a string (except the debug messages which are output
/**
@class wxLogInterposer
- @wxheader{log.h}
A special version of wxLogChain which uses itself as the
new log target. It forwards log messages to the previously installed one in
/**
@class wxLogTextCtrl
- @wxheader{log.h}
Using these target all the log messages can be redirected to a text control.
The text control must have been created with @c wxTE_MULTILINE style by the
/**
@class wxLog
- @wxheader{log.h}
wxLog class defines the interface for the @e log targets used by wxWidgets
logging functions as explained in the @ref overview_log.
/**
@class wxLogNull
- @wxheader{log.h}
This class allows you to temporarily suspend logging. All calls to the log
functions during the life time of an object of this class are just ignored.
/**
@class wxLongLong
- @wxheader{longlong.h}
This class represents a signed 64 bit long number. It is implemented using the
native 64 bit type where available (machines with 64 bit longs or compilers
/**
@class wxMDIClientWindow
- @wxheader{mdi.h}
An MDI client window is a child of wxMDIParentFrame, and manages zero or
more wxMDIChildFrame objects.
/**
@class wxMDIParentFrame
- @wxheader{mdi.h}
An MDI (Multiple Document Interface) parent frame is a window which can contain
MDI child frames in its own 'desktop'. It is a convenient way to avoid window
/**
@class wxMDIChildFrame
- @wxheader{mdi.h}
An MDI child frame is a frame that can only exist on a wxMDIClientWindow,
which is itself a child of wxMDIParentFrame.
/**
@class wxMediaEvent
- @wxheader{mediactrl.h}
Event wxMediaCtrl uses.
/**
@class wxMediaCtrl
- @wxheader{mediactrl.h}
wxMediaCtrl is a class for displaying types of
media, such as videos, audio files, natively through native codecs.
/**
@class wxDebugStreamBuf
- @wxheader{memory.h}
This class allows you to treat debugging output in a similar
(stream-based) fashion on different platforms. Under
/**
@class wxDebugContext
- @wxheader{memory.h}
A class for performing various debugging and memory tracing
operations. Full functionality (such as printing out objects
/**
@class wxMenuBar
- @wxheader{menu.h}
A menu bar is a series of menus accessible from the top of a frame.
/**
@class wxMenu
- @wxheader{menu.h}
A menu is a popup (or pull down) list of items, one of which may be
selected before the menu goes away (clicking elsewhere dismisses the
/**
@class wxMenuItem
- @wxheader{menuitem.h}
A menu item represents an item in a menu. Note that you usually don't have to
deal with it directly as wxMenu methods usually construct an
/**
@class wxMetafileDC
- @wxheader{metafile.h}
This is a type of device context that allows a metafile object to be
created (Windows only), and has most of the characteristics of a normal
/**
@class wxMetafile
- @wxheader{metafile.h}
A @b wxMetafile represents the MS Windows metafile object, so metafile
operations have no effect in X. In wxWidgets, only sufficient functionality
/**
@class wxMimeTypesManager
- @wxheader{mimetype.h}
This class allows the application to retrieve the information about all known
MIME types from a system-specific location and the filename extensions to the
/**
@class wxFileType
- @wxheader{mimetype.h}
This class holds information about a given @e file type. File type is the same
as
/**
@class wxMiniFrame
- @wxheader{minifram.h}
A miniframe is a frame with a small title bar. It is suitable for floating
toolbars that must not
/**
@class wxModule
- @wxheader{module.h}
The module system is a very simple mechanism to allow applications (and parts
of wxWidgets itself) to define initialization and cleanup functions that are
/**
@class wxMessageDialog
- @wxheader{msgdlg.h}
This class represents a dialog that shows a single or multi-line message,
with a choice of OK, Yes, No and Cancel buttons.
/////////////////////////////////////////////////////////////////////////////
/**
- @wxheader{msgqueue.h}
wxMessageQueue allows passing messages between threads.
/**
@class wxMemoryOutputStream
- @wxheader{mstream.h}
@library{wxbase}
/**
@class wxMemoryInputStream
- @wxheader{mstream.h}
@library{wxbase}
/**
@class wxActiveXEvent
- @headerfile ole/activex.h wx/msw/ole/activex.h
An event class for handling activex events passed from wxActiveXContainer.
/**
@class wxActiveXContainer
- @headerfile ole/activex.h wx/msw/ole/activex.h
wxActiveXContainer is a host for an activex control on Windows (and
as such is a platform-specific class). Note that the HWND that the class
/**
@class wxAutomationObject
- @headerfile ole/automtn.h wx/msw/ole/automtn.h
The @b wxAutomationObject class represents an OLE automation object containing
a single data member,
/**
@class wxRegKey
- @wxheader{msw/registry.h}
wxRegKey is a class representing the Windows registry (it is only available
under Windows). One can create, query and delete registry keys using this
/**
@class wxNotebookEvent
- @wxheader{notebook.h}
This class represents the events generated by a notebook control: currently,
there are two of them. The PAGE_CHANGING event is sent before the current
/**
@class wxNotebook
- @wxheader{notebook.h}
This class represents a notebook control, which manages multiple windows with
associated tabs.
/**
@class wxNotificationMessage
- @wxheader{notifmsg.h}
This class allows to show the user a message non intrusively. Currently it is
implemented natively only for the Maemo platform and uses (non-modal) dialogs
/**
@class wxObjectRefData
- @wxheader{object.h}
This class is used to store reference-counted data.
/**
@class wxObject
- @wxheader{object.h}
This is the root class of many of the wxWidgets classes.
/**
@class wxClassInfo
- @wxheader{object.h}
This class stores meta-information about classes.
/**
- @wxheader{object.h}
This is helper template class primarily written to avoid memory leaks because of
missing calls to wxObjectRefData::DecRef().
/**
@class wxOwnerDrawnComboBox
- @wxheader{odcombo.h}
wxOwnerDrawnComboBox is a combobox with owner-drawn list items.
In essence, it is a wxComboCtrl with wxVListBox popup and wxControlWithItems
/**
@class wxPalette
- @wxheader{palette.h}
A palette is a table that maps pixel values to RGB colours. It allows the
colours of a low-depth bitmap, for example, to be mapped to the available
/**
@class wxPanel
- @wxheader{panel.h}
A panel is a window on which controls are placed. It is usually placed within
a frame. Its main feature over its parent class wxWindow is code for handling
/**
@class wxPen
- @wxheader{pen.h}
A pen is a drawing tool for drawing outlines. It is used for drawing
lines and painting the outline of rectangles, ellipses, etc.
/**
@class wxPenList
- @wxheader{gdicmn.h}
There is only one instance of this class: ::wxThePenList.
Use this object to search for a previously created pen of the desired
/**
@class wxPickerBase
- @wxheader{pickerbase.h}
Base abstract class for all pickers which support an auxiliary text control.
/**
@class wxPlatformInfo
- @wxheader{platinfo.h}
This class holds informations about the operating system and the toolkit that
the application is running under and some basic architecture info of the machine
/**
@class wxPopupWindow
- @wxheader{popupwin.h}
A special kind of top level window used for popup menus,
combobox popups and such.
/**
@class wxPosition
- @wxheader{position.h}
This class represents the position of an item in any kind of grid of rows and
columns such as wxGridBagSizer, or wxHVScrolledWindow.
/**
@class wxPowerEvent
- @wxheader{power.h}
The power events are generated when the system power state changes, e.g. the
system is suspended, hibernated, plugged into or unplugged from the wall socket
/**
@class wxPreviewControlBar
- @wxheader{print.h}
This is the default implementation of the preview control bar, a panel
with buttons and a zoom control.
/**
@class wxPreviewCanvas
- @wxheader{print.h}
A preview canvas is the default canvas used by the print preview
system to display the preview.
/**
@class wxPreviewFrame
- @wxheader{print.h}
This class provides the default method of managing the print preview interface.
Member functions may be overridden to replace functionality, or the
/**
@class wxPrintPreview
- @wxheader{print.h}
Objects of this class manage the print preview process. The object is passed
a wxPrintout object, and the wxPrintPreview object itself is passed to
/**
@class wxPrinter
- @wxheader{print.h}
This class represents the Windows or PostScript printer, and is the vehicle
through which printing may be launched by an application.
/**
@class wxPrintout
- @wxheader{print.h}
This class encapsulates the functionality of printing out an application document.
/**
@class wxPrintDialog
- @wxheader{printdlg.h}
This class represents the print and print setup common dialogs.
You may obtain a wxPrinterDC device context from a successfully dismissed
/**
@class wxPageSetupDialog
- @wxheader{printdlg.h}
This class represents the page setup common dialog. In MSW, the page setup
dialog is standard from Windows 95 on, replacing the print setup dialog (which
/**
@class wxProcess
- @wxheader{process.h}
The objects of this class are used in conjunction with the ::wxExecute() function.
When a wxProcess object is passed to ::wxExecute(), its OnTerminate() virtual method
/**
@class wxProcessEvent
- @wxheader{process.h}
A process event is sent when a process is terminated.
/**
@class wxProgressDialog
- @wxheader{progdlg.h}
This class represents a dialog that shows a short message and a
progress bar. Optionally, it can display ABORT and SKIP buttons,
/**
@class wxPropertySheetDialog
- @wxheader{propdlg.h}
This class represents a property sheet dialog: a tabbed dialog
for showing settings. It is optimized to show flat tabs
/**
@class wxFTP
- @headerfile ftp.h wx/protocol/ftp.h
wxFTP can be used to establish a connection to an FTP server and perform all the
usual operations. Please consult the RFC 959 for more details about the FTP
/**
@class wxHTTP
- @headerfile http.h wx/protocol/http.h
wxHTTP can be used to establish a connection to an HTTP server.
/**
@class wxProtocol
- @headerfile protocol.h wx/protocol/protocol.h
Represents a protocol for use with wxURL.
/**
@class wxScopedPtr
- @wxheader{ptr_scpd.h}
This is a simple scoped smart pointer implementation that is similar to
the Boost smart pointers (see http://www.boost.org) but rewritten
/**
@class wxScopedArray
- @wxheader{ptr_scpd.h}
This is a simple scoped smart pointer array implementation that is similar to
the Boost smart pointers (see http://www.boost.org/) but rewritten to
/**
@class wxScopedTiedPtr
- @wxheader{ptr_scpd.h}
This is a variation on the topic of wxScopedPtr. This class is also a smart pointer
but in addition it "ties" the pointer value to another variable. In other words,
/**
- @wxheader{ptr_scpd.h}
A scoped pointer template class. It is the template version of
the old-style @ref classwx_scoped_ptr "scoped pointer macros".
/////////////////////////////////////////////////////////////////////////////
/**
- @wxheader{ptr_shrd.h}
A smart pointer with non-intrusive reference counting. It is modeled after
@c boost::shared_ptr<> and can be used with STL containers and wxVector<T> -
/**
@class wxQuantize
- @wxheader{quantize.h}
Performs quantization, or colour reduction, on a wxImage.
/**
@class wxRadioBox
- @wxheader{radiobox.h}
A radio box item is used to select one of number of mutually exclusive
choices. It is displayed as a vertical column or horizontal row of
/**
@class wxRadioButton
- @wxheader{radiobut.h}
A radio button item is a button which usually denotes one of several
mutually exclusive options. It has a text label next to a (usually) round
/**
@class wxPixelData
- @wxheader{rawbmp.h}
A class template with ready to use implementations for getting
direct and efficient access to wxBitmap's internal data and
/**
@class wxRecursionGuardFlag
- @wxheader{recguard.h}
This is a completely opaque class which exists only to be used with
wxRecursionGuard, please see the example in that class' documentation.
/**
@class wxRecursionGuard
- @wxheader{recguard.h}
wxRecursionGuard is a very simple class which can be used to prevent reentrancy
problems in a function. It is not thread-safe and so should be used only in
/**
@class wxRegEx
- @wxheader{regex.h}
wxRegEx represents a regular expression. This class provides support
for regular expressions matching and also replacement.
/**
@class wxRegionIterator
- @wxheader{region.h}
This class is used to iterate through the rectangles in a region,
typically when examining the damaged regions of a window within an OnPaint call.
/**
@class wxRegion
- @wxheader{region.h}
A wxRegion represents a simple or complex region on a device context or window.
/**
@struct wxSplitterRenderParams
- @wxheader{renderer.h}
This is just a simple @c struct used as a return value of
wxRendererNative::GetSplitterParams().
/**
@struct wxHeaderButtonParams
- @wxheader{renderer.h}
This @c struct can optionally be used with
wxRendererNative::DrawHeaderButton() to specify custom values used to draw
/**
@class wxDelegateRendererNative
- @wxheader{renderer.h}
wxDelegateRendererNative allows reuse of renderers code by forwarding all the
wxRendererNative methods to the given object and
/**
@class wxRendererNative
- @wxheader{renderer.h}
First, a brief introduction to wxRendererNative and why it is needed.
/**
@struct wxRendererVersion
- @wxheader{renderer.h}
This simple struct represents the wxRendererNative
interface version and is only used as the return value of
/**
@class wxRichTextBuffer
- @headerfile richtextbuffer.h wx/richtext/richtextbuffer.h
This class represents the whole buffer associated with a wxRichTextCtrl.
/**
@class wxRichTextFileHandler
- @headerfile richtextbuffer.h wx/richtext/richtextbuffer.h
This is the base class for file handlers, for loading and/or saving content
associated with a wxRichTextBuffer.
/**
@class wxRichTextRange
- @headerfile richtextbuffer.h wx/richtext/richtextbuffer.h
This class stores beginning and end positions for a range of data.
/**
@class wxRichTextEvent
- @headerfile richtextctrl.h wx/richtext/richtextctrl.h
This is the event class for wxRichTextCtrl notifications.
/**
@class wxRichTextCtrl
- @headerfile richtextctrl.h wx/richtext/richtextctrl.h
wxRichTextCtrl provides a generic, ground-up implementation of a text control
capable of showing multiple styles and images.
/**
@class wxRichTextFormattingDialogFactory
- @headerfile richtextformatdlg.h wx/richtext/richtextformatdlg.h
This class provides pages for wxRichTextFormattingDialog, and allows other
customization of the dialog.
/**
@class wxRichTextFormattingDialog
- @headerfile richtextformatdlg.h wx/richtext/richtextformatdlg.h
This dialog allows the user to edit a character and/or paragraph style.
/**
@class wxRichTextHTMLHandler
- @headerfile richtexthtml.h wx/richtext/richtexthtml.h
Handles HTML output (only) for wxRichTextCtrl content.
/**
@class wxRichTextHeaderFooterData
- @headerfile richtextprint.h wx/richtext/richtextprint.h
This class represents header and footer data to be passed to the
/**
@class wxRichTextPrintout
- @headerfile richtextprint.h wx/richtext/richtextprint.h
This class implements print layout for wxRichTextBuffer. Instead of using it
directly, you
/**
@class wxRichTextPrinting
- @headerfile richtextprint.h wx/richtext/richtextprint.h
This class provides a simple interface for performing wxRichTextBuffer printing
and previewing. It uses wxRichTextPrintout for layout and rendering.
/**
@class wxRichTextStyleOrganiserDialog
- @headerfile richtextstyledlg.h wx/richtext/richtextstyledlg.h
This class shows a style sheet and allows the user to edit, add and remove
styles.
/**
@class wxRichTextStyleListCtrl
- @headerfile richtextstyles.h wx/richtext/richtextstyles.h
This class incorporates a wxRichTextStyleListBox and
a choice control that allows the user to select the category of style to view.
/**
@class wxRichTextStyleDefinition
- @headerfile richtextstyles.h wx/richtext/richtextstyles.h
This is a base class for paragraph and character styles.
/**
@class wxRichTextParagraphStyleDefinition
- @headerfile richtextstyles.h wx/richtext/richtextstyles.h
This class represents a paragraph style definition, usually added to a
wxRichTextStyleSheet.
/**
@class wxRichTextStyleListBox
- @headerfile richtextstyles.h wx/richtext/richtextstyles.h
This is a listbox that can display the styles in a wxRichTextStyleSheet,
and apply the selection to an associated wxRichTextCtrl.
/**
@class wxRichTextStyleComboCtrl
- @headerfile richtextstyles.h wx/richtext/richtextstyles.h
This is a combo control that can display the styles in a wxRichTextStyleSheet,
and apply the selection to an associated wxRichTextCtrl.
/**
@class wxRichTextCharacterStyleDefinition
- @headerfile richtextstyles.h wx/richtext/richtextstyles.h
This class represents a character style definition, usually added to a
wxRichTextStyleSheet.
/**
@class wxRichTextListStyleDefinition
- @headerfile richtextstyles.h wx/richtext/richtextstyles.h
This class represents a list style definition, usually added to a
wxRichTextStyleSheet.
/**
@class wxRichTextStyleSheet
- @headerfile richtextstyles.h wx/richtext/richtextstyles.h
A style sheet contains named paragraph and character styles that make it
easy for a user to apply combinations of attributes to a wxRichTextCtrl.
/**
@class wxSymbolPickerDialog
- @headerfile richtextsymboldlg.h wx/richtext/richtextsymboldlg.h
wxSymbolPickerDialog presents the user with a choice of fonts and a grid
of available characters. This modal dialog provides the application with
/**
@class wxRichTextXMLHandler
- @headerfile richtextxml.h wx/richtext/richtextxml.h
A handler for loading and saving content in an XML format specific
to wxRichTextBuffer. You can either add the handler to the buffer
/**
@class wxSashWindow
- @wxheader{sashwin.h}
wxSashWindow allows any of its edges to have a sash which can be dragged
to resize the window. The actual content window will be created by the
/**
@class wxSashEvent
- @wxheader{sashwin.h}
A sash event is sent when the sash of a wxSashWindow has been
dragged by the user.
/**
@class wxTCPServer
- @wxheader{sckipc.h}
A wxTCPServer object represents the server part of a client-server conversation.
It emulates a DDE-style protocol, but uses TCP/IP which is available on most
/**
@class wxTCPClient
- @wxheader{sckipc.h}
A wxTCPClient object represents the client part of a client-server conversation.
It emulates a DDE-style protocol, but uses TCP/IP which is available on most
/**
@class wxTCPConnection
- @wxheader{sckipc.h}
A wxTCPClient object represents the connection between a client and a server.
It emulates a DDE-style protocol, but uses TCP/IP which is available on most
/**
@class wxSocketOutputStream
- @wxheader{sckstrm.h}
This class implements an output stream which writes data from
a connected socket. Note that this stream is purely sequential
/**
@class wxSocketInputStream
- @wxheader{sckstrm.h}
This class implements an input stream which reads data from
a connected socket. Note that this stream is purely sequential
/**
@class wxScrollBar
- @wxheader{scrolbar.h}
A wxScrollBar is a control that represents a horizontal or
vertical scrollbar. It is distinct from the two scrollbars that some windows
/////////////////////////////////////////////////////////////////////////////
/**
- @wxheader{scrolwin.h}
The wxScrolled class manages scrolling for its client area, transforming
the coordinates according to the scrollbar positions, and setting the
/**
@class wxSystemSettings
- @wxheader{settings.h}
wxSystemSettings allows the application to ask for details about
the system. This can include settings such as standard colours, fonts,
/**
@class wxStdDialogButtonSizer
- @wxheader{sizer.h}
This class creates button layouts which conform to the standard button spacing
and ordering defined by the platform
/**
@class wxSizerItem
- @wxheader{sizer.h}
The wxSizerItem class is used to track the position, size and other
attributes of each item managed by a wxSizer. It is not usually necessary
/**
@class wxSizerFlags
- @wxheader{sizer.h}
Container for sizer items flags providing readable names for them.
/**
@class wxNotebookSizer
- @wxheader{sizer.h}
@deprecated
This class is deprecated and should not be used in new code! It is no
/**
@class wxFlexGridSizer
- @wxheader{sizer.h}
A flex grid sizer is a sizer which lays out its children in a two-dimensional
table with all table fields in one row having the same
/**
@class wxSizer
- @wxheader{sizer.h}
wxSizer is the abstract base class used for laying out subwindows in a window.
You
/**
@class wxGridSizer
- @wxheader{sizer.h}
A grid sizer is a sizer which lays out its children in a two-dimensional
table with all table fields having the same size,
/**
@class wxStaticBoxSizer
- @wxheader{sizer.h}
wxStaticBoxSizer is a sizer derived from wxBoxSizer but adds a static
box around the sizer. This static box may be either created independently or
/**
@class wxBoxSizer
- @wxheader{sizer.h}
The basic idea behind a box sizer is that windows will most often be laid out
in rather
/**
@class wxSlider
- @wxheader{slider.h}
A slider is a control with a handle which can be pulled
back and forth to change the value.
/**
@class wxSingleInstanceChecker
- @wxheader{snglinst.h}
wxSingleInstanceChecker class allows to check that only a single instance of a
program is running. To do it, you should create an object of this class. As
/**
@class wxIPV4address
- @wxheader{socket.h}
@library{wxbase}
/**
@class wxSocketServer
- @wxheader{socket.h}
@library{wxnet}
/**
@class wxIPaddress
- @wxheader{socket.h}
wxIPaddress is an abstract base class for all internet protocol address
objects. Currently, only wxIPV4address
/**
@class wxSocketClient
- @wxheader{socket.h}
@library{wxnet}
/**
@class wxSockAddress
- @wxheader{socket.h}
You are unlikely to need to use this class: only wxSocketBase uses it.
/**
@class wxSocketEvent
- @wxheader{socket.h}
This event class contains information about socket events.
/**
@class wxSocketBase
- @wxheader{socket.h}
wxSocketBase is the base class for all socket-related objects, and it
defines all basic IO functionality.
/**
@class wxDatagramSocket
- @wxheader{socket.h}
@library{wxnet}
/**
@class wxSound
- @wxheader{sound.h}
This class represents a short sound (loaded from Windows WAV file), that
can be stored in memory and played. Currently this class is implemented
/**
@class wxSpinEvent
- @wxheader{spinbutt.h}
This event class is used for the events generated by
wxSpinButton and wxSpinCtrl.
/**
@class wxSpinButton
- @wxheader{spinbutt.h}
A wxSpinButton has two small up and down (or left and right) arrow buttons. It
is often used next to a text control for increment and decrementing a value.
/**
@class wxSpinCtrl
- @wxheader{spinctrl.h}
wxSpinCtrl combines wxTextCtrl and
wxSpinButton in one control.
/**
@class wxSplashScreen
- @wxheader{splash.h}
wxSplashScreen shows a window with a thin border, displaying a bitmap
describing your
/**
@class wxSplitterWindow
- @wxheader{splitter.h}
@ref overview_wxsplitterwindowoverview "wxSplitterWindow overview"
/**
@class wxSplitterEvent
- @wxheader{splitter.h}
This class represents the events generated by a splitter control. Also there is
only one event class, the data associated to the different events is not the
/**
@class wxSearchCtrl
- @wxheader{srchctrl.h}
A search control is a composite control with a search button, a text
control, and a cancel button.
/**
@class wxStringInputStream
- @wxheader{sstream.h}
This class implements an input stream which reads data from a string. It
supports seeking.
/**
@class wxStringOutputStream
- @wxheader{sstream.h}
This class implements an output stream which writes data either to a
user-provided or internally allocated string. Note that currently this stream
/**
@class wxStackWalker
- @wxheader{stackwalk.h}
wxStackWalker allows an application to enumerate, or walk, the stack frames
(the function callstack).
/**
@class wxStackFrame
- @wxheader{stackwalk.h}
wxStackFrame represents a single stack frame, or a single function in the call
stack, and is used exclusively together with
/**
@class wxStaticBitmap
- @wxheader{statbmp.h}
A static bitmap control displays a bitmap. Native implementations on some
platforms are only meant for display of the small icons in the dialog
/**
@class wxStaticBox
- @wxheader{statbox.h}
A static box is a rectangle drawn around other panel items to denote
a logical grouping of items.
/**
@class wxStaticLine
- @wxheader{statline.h}
A static line is just a line which may be used in a dialog to separate the
groups of controls. The line may be only vertical or horizontal.
/**
@class wxStaticText
- @wxheader{stattext.h}
A static text control displays one or more lines of read-only text.
/**
@class wxStatusBar
- @wxheader{statusbr.h}
A status bar is a narrow window that can be placed along the bottom of a frame
to give
/**
@class wxStyledTextEvent
- @headerfile stc.h wx/stc/stc.h
The type of events sent from wxStyledTextCtrl.
/**
@class wxStyledTextCtrl
- @headerfile stc.h wx/stc/stc.h
A wxWidgets implementation of the Scintilla source code editing component.
/**
@class wxStandardPaths
- @wxheader{stdpaths.h}
wxStandardPaths returns the standard locations in the file system and should be
used by applications to find their data files in a portable way.
/**
@class wxStopWatch
- @wxheader{stopwatch.h}
The wxStopWatch class allow you to measure time intervals. For example, you may
use it to measure the time elapsed by some function:
/**
@class wxMBConv
- @wxheader{strconv.h}
This class is the base class of a hierarchy of classes capable of
converting text strings between multibyte (SBCS or DBCS) encodings and
/**
@class wxMBConvUTF7
- @wxheader{strconv.h}
This class converts between the UTF-7 encoding and Unicode.
It has one predefined instance, @b wxConvUTF7.
/**
@class wxMBConvUTF8
- @wxheader{strconv.h}
This class converts between the UTF-8 encoding and Unicode.
It has one predefined instance, @b wxConvUTF8.
/**
@class wxMBConvUTF16
- @wxheader{strconv.h}
This class is used to convert between multibyte encodings and UTF-16 Unicode
encoding (also known as UCS-2).
/**
@class wxMBConvUTF32
- @wxheader{strconv.h}
This class is used to convert between multibyte encodings and UTF-32
Unicode encoding (also known as UCS-4).
/**
@class wxCSConv
- @wxheader{strconv.h}
This class converts between any character set supported by the system and
Unicode.
/**
@class wxMBConvFile
- @wxheader{strconv.h}
This class used to define the class instance @b wxConvFileName, but
nowadays @b wxConvFileName is either of type wxConvLibc (on most platforms)
/**
@class wxCountingOutputStream
- @wxheader{stream.h}
wxCountingOutputStream is a specialized output stream which does not write any
data anywhere,
/**
@class wxBufferedInputStream
- @wxheader{stream.h}
This stream acts as a cache. It caches the bytes read from the specified
input stream (See wxFilterInputStream).
/**
@class wxStreamBuffer
- @wxheader{stream.h}
@library{wxbase}
/**
@class wxOutputStream
- @wxheader{stream.h}
wxOutputStream is an abstract base class which may not be used directly.
/**
@class wxFilterClassFactory
- @wxheader{stream.h}
Allows the creation of filter streams to handle compression formats such
as gzip and bzip2.
/**
@class wxFilterOutputStream
- @wxheader{stream.h}
A filter stream has the capability of a normal
stream but it can be placed on top of another stream. So, for example, it
/**
@class wxFilterInputStream
- @wxheader{stream.h}
A filter stream has the capability of a normal stream but it can be placed on
top
/**
@class wxBufferedOutputStream
- @wxheader{stream.h}
This stream acts as a cache. It caches the bytes to be written to the specified
output stream (See wxFilterOutputStream). The
/**
@class wxInputStream
- @wxheader{stream.h}
wxInputStream is an abstract base class which may not be used directly.
/**
@class wxStreamBase
- @wxheader{stream.h}
This class is the base class of most stream related classes in wxWidgets. It
must
/**
@class wxStringBuffer
- @wxheader{string.h}
This tiny class allows to conveniently access the wxString
internal buffer as a writable pointer without any risk of forgetting to restore
/**
@class wxString
- @wxheader{string.h}
wxString is a class representing a Unicode character string.
wxString uses @c std::string internally to store its content
/**
@class wxStringBufferLength
- @wxheader{string.h}
This tiny class allows to conveniently access the wxString
internal buffer as a writable pointer without any risk of forgetting to restore
/**
@class wxSystemOptions
- @wxheader{sysopt.h}
wxSystemOptions stores option/value pairs that wxWidgets itself or
applications can use to alter behaviour at run-time. It can be
/**
@class wxTarInputStream
- @wxheader{tarstrm.h}
Input stream for reading tar files.
/**
@class wxTarClassFactory
- @wxheader{tarstrm.h}
Class factory for the tar archive format. See the base class
for details.
/**
@class wxTarOutputStream
- @wxheader{tarstrm.h}
Output stream for writing tar files.
/**
@class wxTarEntry
- @wxheader{tarstrm.h}
Holds the meta-data for an entry in a tar.
/**
@class wxTaskBarIcon
- @wxheader{taskbar.h}
This class represents a taskbar icon. A taskbar icon is an icon that appears in
the 'system tray' and responds to mouse clicks, optionally with a tooltip above it to help provide information.
/**
@class wxTextAttr
- @wxheader{textctrl.h}
wxTextAttr represents the character and paragraph attributes, or style,
for a range of text in a wxTextCtrl or wxRichTextCtrl.
/**
@class wxTextCtrl
- @wxheader{textctrl.h}
A text control allows text to be displayed and edited.
/**
@class wxStreamToTextRedirector
- @wxheader{textctrl.h}
This class can be used to (temporarily) redirect all output sent to a C++
ostream object to a wxTextCtrl instead.
/**
@class wxPasswordEntryDialog
- @wxheader{textdlg.h}
This class represents a dialog that requests a one-line password string from
the user.
/**
@class wxTextEntryDialog
- @wxheader{textdlg.h}
This class represents a dialog that requests a one-line text string from the
user.
/**
@class wxTextFile
- @wxheader{textfile.h}
The wxTextFile is a simple class which allows to work with text files on line by
line basis. It also understands the differences in line termination characters
/**
@class wxToggleButton
- @wxheader{tglbtn.h}
wxToggleButton is a button that stays pressed when clicked by the user. In
other words, it is similar to wxCheckBox in
/**
@class wxBitmapToggleButton
- @wxheader{tglbtn.h}
wxBitmapToggleButton is a wxToggleButton
that contains a bitmap instead of text.
/**
@class wxCondition
- @wxheader{thread.h}
wxCondition variables correspond to pthread conditions or to Win32 event
objects. They may be used in a multithreaded application to wait until the
/**
@class wxCriticalSectionLocker
- @wxheader{thread.h}
This is a small helper class to be used with wxCriticalSection
objects. A wxCriticalSectionLocker enters the critical section in the
/**
@class wxThreadHelper
- @wxheader{thread.h}
The wxThreadHelper class is a mix-in class that manages a single background
thread. By deriving from wxThreadHelper, a class can implement the thread
/**
@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
/**
@class wxThread
- @wxheader{thread.h}
A thread is basically a path of execution through a program. Threads are
sometimes called @e light-weight processes, but the fundamental difference
/**
@class wxSemaphore
- @wxheader{thread.h}
wxSemaphore is a counter limiting the number of threads concurrently accessing
a shared resource. This counter is always between 0 and the maximum value
/**
@class wxMutexLocker
- @wxheader{thread.h}
This is a small helper class to be used with wxMutex
objects. A wxMutexLocker acquires a mutex lock in the constructor and releases
/**
@class wxMutex
- @wxheader{thread.h}
A mutex object is a synchronization object whose state is set to signaled when
it is not owned by any thread, and nonsignaled when it is owned. Its name comes
/**
@class wxTimer
- @wxheader{timer.h}
The wxTimer class allows you to execute code at specified intervals. Its
precision is platform-dependent, but in general will not be better than 1ms nor
/**
@class wxTimerEvent
- @wxheader{timer.h}
wxTimerEvent object is passed to the event handler of timer events.
/**
@class wxTipProvider
- @wxheader{tipdlg.h}
This is the class used together with wxShowTip() function.
It must implement wxTipProvider::GetTip function and return the
/**
@class wxTipWindow
- @wxheader{tipwin.h}
Shows simple text in a popup tip window on creation. This is used by
wxSimpleHelpProvider to show popup help. The
/**
@class wxStringTokenizer
- @wxheader{tokenzr.h}
wxStringTokenizer helps you to break a string up into a number of tokens.
It replaces the standard C function @c strtok() and also extends it in a
/**
@class wxToolBar
- @wxheader{toolbar.h}
The name wxToolBar is defined to be a synonym for one of the following
classes:
/**
@class wxToolbook
- @wxheader{toolbook.h}
wxToolbook is a class similar to wxNotebook but which uses a wxToolBar to
show the labels instead of the tabs.
/**
@class wxToolTip
- @wxheader{tooltip.h}
This class holds information about a tooltip associated with a window (see
wxWindow::SetToolTip()).
/**
@class wxTopLevelWindow
- @wxheader{toplevel.h}
wxTopLevelWindow is a common base class for wxDialog and wxFrame. It is an
abstract base class meaning that you never work with objects of this class
/**
@class wxTrackable
- @wxheader{tracker.h}
Add-on base class for a trackable object. This class maintains an internal
linked list of classes of type wxTrackerNode and calls OnObjectDestroy() on
/**
@class wxTreeItemId
- @wxheader{treebase.h}
An opaque reference to a tree item.
/**
@class wxTreeItemData
- @wxheader{treebase.h}
wxTreeItemData is some (arbitrary) user class associated with some item. The
main advantage of having this class is that wxTreeItemData objects are
/**
@class wxTreebookEvent
- @wxheader{treebook.h}
This class represents the events generated by a treebook control: currently,
there are four of them. The EVT_TREEBOOK_PAGE_CHANGING() and
/**
@class wxTreebook
- @wxheader{treebook.h}
This class is an extension of the wxNotebook class that allows a tree
structured set of pages to be shown in a control. A classic example is a
/**
@class wxTreeCtrl
- @wxheader{treectrl.h}
A tree control presents information as a hierarchy, with items that may be
expanded to show further items. Items in a tree control are referenced by
/**
@class wxTreeEvent
- @wxheader{treectrl.h}
A tree event holds information about events associated with wxTreeCtrl
objects.
/**
@class wxTextInputStream
- @wxheader{txtstrm.h}
This class provides functions that reads text data using an input stream,
allowing you to read text, floats, and integers.
/**
@class wxTextOutputStream
- @wxheader{txtstrm.h}
This class provides functions that write text data using an output stream,
allowing you to write text, floats, and integers.
/**
@class wxURI
- @wxheader{uri.h}
wxURI is used to extract information from a URI (Uniform Resource
Identifier).
/**
@class wxURL
- @wxheader{url.h}
wxURL is a specialization of wxURI for parsing URLs. Please look at wxURI
documentation for more info about the functions you can use to retrieve the
/**
@class wxWindowDisabler
- @wxheader{utils.h}
This class disables all windows of the application (may be with the
exception of one of them) in its constructor and enables them back in its
/**
@class wxBusyCursor
- @wxheader{utils.h}
This class makes it easy to tell your user that the program is temporarily
busy. Just create a wxBusyCursor object on the stack, and within the
/**
@class wxMouseState
- @wxheader{utils.h}
Represents the mouse state.
/**
@class wxGenericValidator
- @wxheader{valgen.h}
wxGenericValidator performs data transfer (but not validation or filtering)
for the following basic controls: wxButton, wxCheckBox, wxListBox,
/**
@class wxValidator
- @wxheader{validate.h}
wxValidator is the base class for a family of validator classes that
mediate between a class of control, and application data.
/**
@class wxTextValidator
- @wxheader{valtext.h}
wxTextValidator validates text controls, providing a variety of filtering
behaviours.
/**
@class wxVariant
- @wxheader{variant.h}
The wxVariant class represents a container for any type. A variant's value
can be changed at run time, possibly to a different type of value.
/**
@class wxVariantData
- @wxheader{variant.h}
The wxVariantData class is used to implement a new type for wxVariant.
Derive from wxVariantData, and override the pure virtual functions.
/////////////////////////////////////////////////////////////////////////////
/**
- @wxheader{vector.h}
wxVector<T> is a template class which implements most of the @c std::vector
class and can be used like it.
/**
@struct wxVideoMode
- @wxheader{display.h}
Determines the sizes and locations of displays connected to the system.
/**
@class wxVListBox
- @wxheader{vlbox.h}
wxVListBox is a wxListBox-like control with the following two main
differences from a regular wxListBox: it can have an arbitrarily huge
/**
@class wxVarScrollHelperBase
- @wxheader{vscroll.h}
This class provides all common base functionality for scroll calculations
shared among all variable scrolled window implementations as well as
/**
@class wxVarVScrollHelper
- @wxheader{vscroll.h}
This class provides functions wrapping the wxVarScrollHelperBase class,
targeted for vertical-specific scrolling.
/**
@class wxVarHScrollHelper
- @wxheader{vscroll.h}
This class provides functions wrapping the wxVarScrollHelperBase class,
targeted for horizontal-specific scrolling.
/**
@class wxVarHVScrollHelper
- @wxheader{vscroll.h}
This class provides functions wrapping the wxVarHScrollHelper and
wxVarVScrollHelper classes, targeted for scrolling a window in both axis.
/**
@class wxVScrolledWindow
- @wxheader{vscroll.h}
In the name of this class, "V" may stand for "variable" because it can be
used for scrolling rows of variable heights; "virtual", because it is not
/**
@class wxHScrolledWindow
- @wxheader{vscroll.h}
In the name of this class, "H" stands for "horizontal" because it can be
used for scrolling columns of variable widths. It is not necessary to know
/**
@class wxHVScrolledWindow
- @wxheader{vscroll.h}
This window inherits all functionality of both vertical and horizontal,
variable scrolled windows. It automatically handles everything needed to
/////////////////////////////////////////////////////////////////////////////
/**
- @wxheader{weakref.h}
wxWeakRefDynamic<T> is a template class for weak references that is used in
the same way as wxWeakRef<T>. The only difference is that wxWeakRefDynamic
/**
- @wxheader{weakref.h}
wxWeakRef is a template class for weak references to wxWidgets objects,
such as wxEvtHandler, wxWindow and
/**
@class wxTempFileOutputStream
- @wxheader{wfstream.h}
wxTempFileOutputStream is an output stream based on wxTempFile. It
provides a relatively safe way to replace the contents of the
/**
@class wxFFileOutputStream
- @wxheader{wfstream.h}
This class represents data written to a file. There are actually
two such groups of classes: this one is based on wxFFile
/**
@class wxFileOutputStream
- @wxheader{wfstream.h}
This class represents data written to a file. There are actually
two such groups of classes: this one is based on wxFile
/**
@class wxFileInputStream
- @wxheader{wfstream.h}
This class represents data read in from a file. There are actually
two such groups of classes: this one is based on wxFile
/**
@class wxFFileInputStream
- @wxheader{wfstream.h}
This class represents data read in from a file. There are actually
two such groups of classes: this one is based on wxFFile
/**
@class wxFFileStream
- @wxheader{wfstream.h}
@library{wxbase}
/**
@class wxFileStream
- @wxheader{wfstream.h}
@library{wxbase}
/**
@class wxWindow
- @wxheader{window.h}
wxWindow is the base class for all windows and represents any visible object on
screen. All controls, top level windows and so on are windows. Sizers and
/**
@class wxIdManager
- @wxheader{windowid.h}
wxIdManager is responsible for allocating and releasing window IDs. It
is used by wxWindow::NewControlId and
/**
@class wxWizardPage
- @wxheader{wizard.h}
wxWizardPage is one of the screens in wxWizard: it must
know what are the following and preceding pages (which may be @NULL for the
/**
@class wxWizardEvent
- @wxheader{wizard.h}
wxWizardEvent class represents an event generated by the
wizard(): this event is first sent to the page itself and,
/**
@class wxWizardPageSimple
- @wxheader{wizard.h}
wxWizardPageSimple is the simplest possible
wxWizardPage implementation: it just returns the
/**
@class wxWizard
- @wxheader{wizard.h}
wxWizard is the central class for implementing 'wizard-like' dialogs. These
dialogs are mostly familiar to Windows users and are nothing other than a
/**
@class wxWrapSizer
- @wxheader{wrapsizer.h}
A wrap sizer lays out its items in a single line, like a box sizer -- as long
as there is space available in that direction. Once all available space in
/**
@class wxWindowUpdateLocker
- @wxheader{wupdlock.h}
This tiny class prevents redrawing of a wxWindow during its
lifetime by using wxWindow::Freeze and
/**
@class wxXmlNode
- @headerfile xml.h wx/xml/xml.h
Represents a node in an XML document. See wxXmlDocument.
/**
@class wxXmlAttribute
- @headerfile xml.h wx/xml/xml.h
Represents a node attribute.
/**
@class wxXmlDocument
- @headerfile xml.h wx/xml/xml.h
This class holds XML data/document as parsed by XML parser in the root node.
/**
@class wxXmlResource
- @headerfile xmlres.h wx/xrc/xmlres.h
This is the main class for interacting with the XML-based resource system.
/**
@class wxXmlResourceHandler
- @headerfile xmlres.h wx/xrc/xmlres.h
wxXmlResourceHandler is an abstract base class for resource handlers
capable of creating a control from an XML node.
/**
@class wxZipNotifier
- @wxheader{zipstrm.h}
If you need to know when a wxZipInputStream
updates a wxZipEntry,
/**
@class wxZipEntry
- @wxheader{zipstrm.h}
Holds the meta-data for an entry in a zip.
/**
@class wxZipInputStream
- @wxheader{zipstrm.h}
Input stream for reading zip files.
/**
@class wxZipClassFactory
- @wxheader{zipstrm.h}
Class factory for the zip archive format. See the base class
for details.
/**
@class wxZipOutputStream
- @wxheader{zipstrm.h}
Output stream for writing zip files.
/**
@class wxZlibOutputStream
- @wxheader{zstream.h}
This stream compresses all data written to it. The compressed output can be
in zlib or gzip format.
/**
@class wxZlibInputStream
- @wxheader{zstream.h}
This filter stream decompresses a stream that is in zlib or gzip format.
Note that reading the gzip format requires zlib version 1.2.1 or greater,
projects / wxWidgets.git / commitdiff
