A convenience class for :class:`wx.Timer`, that calls the given callable

This is the main class for interacting with the XML-based resource system.

:ref:`SizerXmlHandler`  is a class for resource handlers capable of creating a :ref:`wx.Sizer`  object from an ``XML`` node.

This class holds ``XML`` data/document as parsed by ``XML`` parser in the root node.

This is the base class for :ref:`wx.glcanvas.GLAttributes`  and :ref:`wx.glcanvas.GLContextAttrs`.

This class is used for setting display attributes when drawing through OpenGL ("Pixel format" in MSW and OSX parlance, "Configs" in X11).

An instance of a :ref:`wx.glcanvas.GLContext`  represents the state of an OpenGL state machine and the connection between OpenGL and the system.

:ref:`wx.glcanvas.GLCanvas`  is a class for displaying OpenGL graphics.

A wxWidgets implementation of the Scintilla source code editing component.

This class is used to manage reference-counting providing a simple interface and a counter.

This class is a mixin that provides storage and management of "client data".

This class is a replacement for :ref:`wx.ClientDataContainer`, and unlike :ref:`wx.ClientDataContainer`  the :ref:`wx.SharedClientDataContainer`  client data is copiable, so it can be copied when objects containing it are cloned.

:ref:`wx.DateTime`  class represents an absolute moment in time.

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, doesn't mean to add 60x60x24x31 seconds to it, but to take the same date the next month (to understand that this is indeed different consider adding one month to Feb, 15 –  we want to get Mar, 15, of course).

The :ref:`wx.StopWatch`  class allow you to measure time intervals.

:ref:`wx.IdManager`  is responsible for allocating and releasing window IDs.

A WindowIDRef object wraps an ``ID`` value and marks it as being in-use until all references to that ``ID`` are gone.

This class holds information about the operating system, the toolkit and the basic architecture bitness of the machine where the application is currently running.

A structure containing information about a Linux distribution as returned by the  ``lsb_release``   utility.

Determines the sizes and locations of displays connected to the system.

Encapsulates a :ref:`wx.Language`  identifier together with OS-specific information related to that language.

:ref:`wx.Locale`  class encapsulates all language-dependent settings and is a generalization of the C locale concept.

This class holds a variety of information related to :ref:`wx.PageSetupDialog`.

This class holds a variety of information related to printers and printer device contexts.

This class holds information related to the visual characteristics of :ref:`wx.PrintDialog`.

A :ref:`wx.Point`  is a useful data structure for graphics operations.

A :ref:`wx.Size`  is a useful data structure for graphics operations.

A :ref:`wx.RealPoint`  is a useful data structure for graphics operations.

wxWidgets maintains a database of standard ``RGB`` colours for a predefined set of named colours.

This class represents the position of an item in any kind of grid of rows and columns such as :ref:`wx.GridBagSizer`, or :ref:`wx.HVScrolledWindow`.

A colour is an object representing a combination of Red, Green, and Blue (``RGB``) intensity values and an Alpha value, and is used to determine drawing colours.

This class is the base class of most stream related classes in wxWidgets.

:ref:`wx.InputStream`  is an abstract base class which may not be used directly.

:ref:`wx.OutputStream`  is an abstract base class which may not be used directly.

This class provides an interface for opening files on different file systems.

This class represents a single file opened by :ref:`wx.FileSystem`.

Classes derived from :ref:`wx.FileSystemHandler`  are used to access virtual file systems.

This :ref:`wx.FileSystem`  handler can store arbitrary data in memory stream and make them accessible via an URL.

A file system handler for accessing files from internet servers.

A simple class which stores hue, saturation and value as doubles in the range 0.0-1.0.

A simple class which stores red, green and blue values as 8 bit  integers in the range of ``0-255``.

This is the base class for implementing image file loading/saving, and image creation from data.

This class allows platforms to implement functionality to optimise GDI objects, such as :ref:`wx.Pen`, :ref:`wx.Brush`  and :ref:`wx.Font`.

This class encapsulates the concept of a platform-dependent bitmap, either monochrome or colour or colour with alpha channel support.

This class encapsulates a monochrome mask bitmap, where the masked area is black and the unmasked area is white.

Contains representations of the same bitmap in different resolutions.

Base class for custom implementations of :ref:`wx.BitmapBundle`.

An icon is a small rectangular bitmap usually used for denoting a minimized application.

:ref:`wx.IconLocation`  is a tiny class describing the location of an (external, i.e.

This class contains multiple copies of an icon in different sizes.

This class is a helper used for :ref:`wx.Font`  creation using named parameter idiom: it allows specifying various :ref:`wx.Font`  attributes using the chained calls to its clearly named methods instead of passing them in the fixed order to :ref:`wx.Font`  constructors.

A font list is a list containing all fonts which have been created.

:ref:`wx.NativeFontInfo`  is platform-specific font representation: this class should be considered as an opaque font description only used by the native functions, the user code can only get the objects of this type from somewhere and pass it somewhere else (possibly save them somewhere using :ref:`wx.ToString`  and restore them using :ref:`wx.FromString`)

This class is a helper used for :ref:`wx.Pen`  creation using named parameter idiom: it allows specifying various :ref:`wx.Pen`  attributes using the chained calls to its clearly named methods instead of passing them in the fixed order to :ref:`wx.Pen`  constructors.

A brush list is a list containing all brushes which have been created.

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 mouse click.

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.

A :ref:`wx.Region`  represents a simple or complex region on a device context or window.

A :ref:`wx.DC`  is a `"device context"`  onto which graphics and text can be drawn.

:ref:`wx.DCClipper`  is a helper class for setting a clipping region on a :ref:`wx.DC`  during its lifetime.

:ref:`wx.DCBrushChanger`  is a small helper class for setting a brush on a :ref:`wx.DC`  and unsetting it automatically in the destructor, restoring the previous one.

:ref:`wx.DCPenChanger`  is a small helper class for setting a pen on a :ref:`wx.DC`  and unsetting it automatically in the destructor, restoring the previous one.

:ref:`wx.DCTextColourChanger`  is a small helper class for setting a foreground text colour on a :ref:`wx.DC`  and unsetting it automatically in the destructor, restoring the previous one.

:ref:`wx.DCFontChanger`  is a small helper class for setting a font on a :ref:`wx.DC`  and unsetting it automatically in the destructor, restoring the previous one.

:ref:`wx.DCTextBgColourChanger`  is a small helper class for setting a background text colour on a :ref:`wx.DC`  and unsetting it automatically in the destructor, restoring the previous one.

:ref:`wx.DCTextBgModeChanger`  is a small helper class for setting a background text mode on a :ref:`wx.DC`  and unsetting it automatically in the destructor, restoring the previous one.

A :ref:`wx.WindowDC`  must be constructed if an application wishes to paint on the whole area of a window (client and decorations).

:ref:`wx.ClientDC`  is primarily useful for obtaining information about the window from outside EVT_PAINT() handler.

A :ref:`wx.PaintDC`  must be constructed if an application wishes to paint on the client area of a window from within an EVT_PAINT() event handler.

A memory device context provides a means to draw graphics onto a bitmap.

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 :ref:`wx.Bitmap`) and then copied to the screen, using the associated :ref:`wx.DC`, only once, when this object is destroyed.

This is a subclass of :ref:`wx.BufferedDC`  which can be used inside of an  ``EVT_PAINT()``   event handler to achieve double-buffered drawing.

This :ref:`wx.DC`  derivative can be used inside of an  ``EVT_PAINT()``   event handler to achieve double-buffered drawing.

:ref:`wx.GCDC`  is a device context that draws on a :ref:`wx.GraphicsContext`.

:ref:`wx.MirrorDC`  is a simple wrapper class which is always associated with a real :ref:`wx.DC`  object and either forwards all of its operations to it without changes (no mirroring takes place) or exchanges `x`  and `y`  coordinates which makes it possible to reuse the same code to draw a figure and its mirror –  i.e.

A printer device context is specific to MSW and Mac, and allows access to any printer with a Windows or Macintosh driver.

This defines the wxWidgets Encapsulated PostScript device context, which can write PostScript files on any platform.

A :ref:`wx.SVGFileDC`  is a device context onto which graphics and text can be drawn, and the output produced as a vector file, in ``SVG`` format.

Abstract base class for handling bitmaps inside a :ref:`wx.SVGFileDC`.

Handler embedding bitmaps as base64-encoded PNGs into the ``SVG``.

Handler saving bitmaps to external ``PNG`` files and linking to it from the ``SVG``.

A  ** :ref:`wx.Metafile` **   represents the MS Windows metafile object, so metafile operations have no effect in X.

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  ** :ref:`wx.DC` ** .

This class is the superclass of native graphics objects like pens etc.

A :ref:`wx.GraphicsBrush`  is a native representation of a brush.

This class is a helper used for :ref:`wx.GraphicsPen`  creation using named parameter idiom: it allows specifying various :ref:`wx.GraphicsPen`  attributes using the chained calls to its clearly named methods instead of passing them in the fixed order to :ref:`wx.GraphicsPen`  constructors.

A :ref:`wx.GraphicsContext`  instance is the object that is drawn upon.

Represents a single gradient stop in a collection of gradient stops as represented by :ref:`wx.GraphicsGradientStops`.

Represents a collection of GraphicGradientStop values for use with CreateLinearGradientBrush and CreateRadialGradientBrush.

A :ref:`wx.GraphicsMatrix`  is a native representation of an affine matrix.

A :ref:`wx.GraphicsPath`  is a native representation of a geometric path.

A :ref:`wx.GraphicsRenderer`  is the instance corresponding to the rendering engine used.

A :ref:`wx.ImageList`  contains a list of images, which are stored in an unspecified form.

Creates an overlay over an existing window, allowing for manipulations like rubberbanding, etc.

This is just a simple  ``struct``   used as a return value of  :meth:`wx.RendererNative.GetSplitterParams` .

This  ``struct``   can optionally be used with  :meth:`wx.RendererNative.DrawHeaderButton`   to specify custom values used to draw the text or bitmap label.

First, a brief introduction to :ref:`wx.RendererNative`  and why it is needed.

:ref:`wx.DelegateRendererNative`  allows reuse of renderers code by forwarding all the :ref:`wx.RendererNative`  methods to the given object and thus allowing you to only modify some of its methods –  without having to reimplement all of them.

This simple struct represents the :ref:`wx.RendererNative`  interface version and is only used as the return value of :meth:`wx.RendererNative.GetVersion` .

The :ref:`wx.Accessible`  class allows wxWidgets applications, and wxWidgets itself, to return extended information about user interface elements to client applications such as screen readers.

An object used by an application wishing to create an accelerator table (see :ref:`wx.AcceleratorTable`).

An accelerator table allows the application to specify a table of keyboard shortcuts for menu or button commands.

:ref:`wx.Log`  class defines the interface for the `log targets`  used by wxWidgets logging functions as explained in the :ref:`Logging Overview <logging overview>`.

This is the default log target for the GUI wxWidgets applications.

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 :meth:`wx.Log.SetActiveTarget`   does.

A special version of :ref:`wx.LogChain`  which uses itself as the new log target.

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 log target which was active at the moment of its creation.

This class can be used to redirect the log messages to a C file stream (not to be confused with C++ streams).

:ref:`wx.LogBuffer`  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 in the usual way immediately as we're presumably not interested in collecting them for later).

Using these target all the log messages can be redirected to a text control.

:ref:`wx.LogFormatter`  class is used to format the log messages.

A :ref:`wx.DataFormat`  is an encapsulation of a platform-specific format handle which is used by the system for the clipboard and drag and drop operations.

A :ref:`wx.DataObject`  represents data that can be copied to or from the clipboard, or dragged and dropped.

This is the simplest possible implementation of the :ref:`wx.DataObject`  class.

:ref:`wx.CustomDataObject`  is a specialization of :ref:`wx.DataObjectSimple`  for some application-specific data in arbitrary (either custom or one of the standard ones).

:ref:`wx.DataObjectComposite`  is the simplest :ref:`wx.DataObject`  derivation which may be used to support multiple formats.

:ref:`wx.BitmapDataObject`  is a specialization of :ref:`wx.DataObject`  for bitmap data.

:ref:`wx.TextDataObject`  is a specialization of :ref:`wx.DataObjectSimple`  for text data.

:ref:`wx.URLDataObject`  is a :ref:`wx.DataObject`  containing an URL and can be used e.g.

:ref:`wx.FileDataObject`  is a specialization of :ref:`wx.DataObject`  for file names.

:ref:`wx.HTMLDataObject`  is used for working with HTML-formatted text.

:ref:`wx.ImageDataObject`  is a specialization of :ref:`wx.DataObject`  for image data.

This is a drop target which accepts files (dragged from File Manager or Explorer).

:ref:`wx.ConfigBase`  defines the basic interface of all config classes.

:ref:`wx.FileConfig`  implements :ref:`wx.ConfigBase`  interface for storing and retrieving configuration information using plain text files.

A handy little class which changes the current path in a Config object and restores it in dtor.

Provides methods for testing the state of the keyboard modifier keys.

This class holds information about a tooltip associated with a window (see :meth:`wx.Window.SetToolTip` ).

This class is a special event handler which allows discarding any event (or a set of event types) directed to a specific window.

An event is a structure holding information about an event passed to a callback or member function.

This event class contains information about command events, which originate from a variety of simple controls.

An activate event is sent when a window or application is being activated or deactivated.

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 child if it loses it now and regains later.

This class represents the events generated by a control (typically a :ref:`wx.TextCtrl`  but other windows can generate these events as well) when its content gets copied or cut to, or pasted from the clipboard.

This event class contains information about window and session close events.

This class is used for context menu events, sent to give the application a chance to show a context (popup) menu for a :ref:`wx.Window`.

A display changed event is sent to top-level windows when the display resolution has changed.

Event sent when the display scale factor or pixel density (measured in dots-per-inch, or ``DPI``) of the monitor a window is on changes.

This class is used for drop files events, that is, when files have been dropped onto the window.

An erase event is sent when a window's background needs to be repainted.

A help event is sent when the user has requested context-sensitive help.

An event being sent when the frame is iconized (minimized) or restored.

This class is used for idle events, which are generated when the system becomes idle.

A :ref:`wx.InitDialogEvent`  is sent as a dialog or panel is being initialised.

This event class contains information about joystick events, particularly events received by windows.

This event class contains information about key press and release events.

An event being sent when the user enters or exits full screen mode.

A mouse capture changed event is sent to a window that loses its mouse capture.

A mouse capture lost event is sent to a window that had obtained mouse capture, which was subsequently lost due to an "external" event (for example, when a dialog box is shown or if another application captures the mouse).

This event class contains information about the events generated by the mouse: they include mouse buttons press and release events and mouse move events.

This event class contains information about navigation events, generated by navigation keys such as tab and page down.

This class is not used by the event handlers by itself, but is a base class for other event classes (such as :ref:`wx.BookCtrlEvent`).

A paint event is sent when a window's contents needs to be repainted.

A scroll event holds information about events sent from stand-alone scrollbars (see :ref:`wx.ScrollBar`) and sliders (see :ref:`wx.Slider`).

A scroll event holds information about events sent from scrolling windows.

A :ref:`wx.SetCursorEvent`  is generated from :ref:`wx.Window`  when the mouse cursor is about to be set as a result of mouse motion.

A size event holds information about size change events of :ref:`wx.Window`.

This class is used for system colour change events, which are generated when the user changes the colour settings or when the system theme changes (e.g.

This class is used for pseudo-events which are called by wxWidgets to give an application the chance to update various user interface elements.

This event is sent just after the actual window associated with a :ref:`wx.Window`  object has been created.

This event is sent as early as possible during the window destruction process.

This event is generated when the user moves a finger on the surface.

This event is generated when two fingers pinch the surface to zoom in or out.

This event is generated when two fingers move in opposite directions on the surface.

This event is generated when two fingers touch the surface at the same time.

This event is generated when one finger touches the surface and remains stationary.

This event is generated when the user press the surface with one finger and taps with another.

Instances of this class are used to bind specific events to event handlers.

:class:`PyEvent` can be used as a base class for implementing custom

:class:`PyCommandEvent` can be used as a base class for implementing

The :ref:`wx.SizerItem`  class is used to track the position, size and other attributes of each item managed by a :ref:`wx.Sizer`.

Container for sizer items flags providing readable names for them.

:ref:`wx.Sizer`  is the abstract base class used for laying out subwindows in a window.

The basic idea behind a box sizer is that windows will most often be laid out in rather simple basic geometry, typically in a row or a column or several hierarchies of either.

:ref:`wx.StaticBoxSizer`  is a sizer derived from :ref:`wx.BoxSizer`  but adds a static box around the sizer.

A grid sizer is a sizer which lays out its children in a two-dimensional table with all table fields having the same size, i.e.

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 height and all fields in one column having the same width, but all rows or all columns are not necessarily the same height or width as in the :ref:`wx.GridSizer`.

This class creates button layouts which conform to the standard button spacing and ordering defined by the platform or toolkit's user interface guidelines (if such things exist).

This class represents the position of an item in a virtual grid of rows and columns managed by a :ref:`wx.GridBagSizer`.

This class is used to hold the row and column spanning attributes of items in a :ref:`wx.GridBagSizer`.

The :ref:`wx.GBSizerItem`  class is used by the :ref:`wx.GridBagSizer`  for tracking the items in the sizer.

A :ref:`wx.Sizer`  that can lay out items in a virtual grid like a :ref:`wx.FlexGridSizer`  but in this case explicit positioning of the items is allowed using :ref:`wx.GBPosition`, and items can optionally span more than one row and/or column using :ref:`wx.GBSpan`.

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.

:ref:`wx.StandardPaths`  returns the standard locations in the file system and should be used by applications to find their data files in a portable way.

A global event filter for pre-processing all the events generated in the program.

The :ref:`wx.AppTraits`  class defines various configurable aspects of a :ref:`wx.App`.

This class is essential for writing console-only or hybrid apps without having to define  ``USE_GUI=0`` .

The :ref:`wx.App`  class represents the application itself when  ``USE_GUI=1`` .

The :ref:`wx.Timer`  class allows you to execute code at specified intervals.

:ref:`wx.TimerEvent`  object is passed to the event handler of timer events (see :meth:`wx.Timer.SetOwner` ).

Helper for ensuring :meth:`~wx.Window.ChildrenRepositioningGuard.EndRepositioningChildren`  is called correctly.

:ref:`wx.Window`  is the base class for all windows and represents any visible object on screen.

:ref:`wx.Validator`  is the base class for a family of validator classes that mediate between a class of control, and application data.

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 menu).

A menu bar is a series of menus accessible from the top of a frame.

The :ref:`wx.Scrolled`  class manages scrolling for its client area, transforming the coordinates according to the scrollbar positions, and setting the scroll positions, thumb sizes and ranges according to the area in view.

The :ref:`ScrolledCanvas` class is a combination of the :ref:`Window` and

This class provides all common base functionality for scroll calculations shared among all variable scrolled window implementations as well as automatic scrollbar functionality, saved scroll positions, controlling target windows to be scrolled, as well as defining all required virtual functions that need to be implemented for any orientation specific work.

This class provides functions wrapping the :ref:`wx.VarScrollHelperBase`  class, targeted for vertical-specific scrolling.

This class provides functions wrapping the :ref:`wx.VarScrollHelperBase`  class, targeted for horizontal-specific scrolling.

This class provides functions wrapping the :ref:`wx.VarHScrollHelper`  and :ref:`wx.VarVScrollHelper`  classes, targeted for scrolling a window in both axis.

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 necessary to know the heights of all rows in advance –  only those which are shown on the screen need to be measured; or even "vertical", because this class only supports scrolling vertically.

In the name of this class, "H" stands for "horizontal" because it can be used for scrolling columns of variable widths.

This window inherits all functionality of both vertical and horizontal, variable scrolled windows.

:ref:`wx.ItemContainer`  defines an interface which is implemented by all controls which have string subitems each of which may be selected.

This class is an abstract base class for some wxWidgets controls which contain several items such as :ref:`wx.ListBox`, :ref:`wx.CheckListBox`, :ref:`wx.ComboBox`  or :ref:`wx.Choice`.

This is convenience class that derives from both :ref:`wx.Control`  and :ref:`wx.ItemContainer`.

A static text control displays one or more lines of read-only text.

A static box is a rectangle drawn around other windows to denote a logical grouping of items.

A status bar is a narrow window that can be placed along the bottom of a frame to give small amounts of status information.

A class for common button functionality used as the base for the various button classes.

A button is a control that contains a text string, and is one of the most common elements of a GUI.

A mixin class to be used with other classes that use a :ref:`wx.ImageList`.

A book control is a convenient way of displaying multiple pages of information, displayed one page at a time.

This class represents the events generated by book controls (:ref:`wx.Notebook`, :ref:`wx.Listbook`, :ref:`wx.Choicebook`, :ref:`wx.Treebook`, :ref:`wx.aui.AuiNotebook`).

This class represents a notebook control, which manages multiple windows with associated tabs.

This class represents the events generated by a splitter control.

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.

This event class is used for the events generated by :ref:`wx.CollapsiblePane`.

A static line is just a line which may be used in a dialog to separate the groups of controls.

:ref:`wx.TextAttr`  represents the character and paragraph attributes, or style, for a range of text in a :ref:`wx.TextCtrl`  or :ref:`wx.richtext.RichTextCtrl`.

A combobox is like a combination of an edit control and a listbox.

A checkbox is a labelled box which by default is either on (checkmark is visible) or off (no checkmark).

A :ref:`wx.CheckListBox`  is like a :ref:`wx.ListBox`, but allows items to be checked or unchecked.

A gauge is a horizontal or vertical bar which shows a quantity (often time).

Represents a column header in controls displaying tabular data such as :ref:`wx.dataview.DataViewCtrl`  or :ref:`wx.grid.Grid`.

Adds methods to set the column attributes to :ref:`wx.HeaderColumn`.

:ref:`wx.HeaderCtrl`  is the control containing the column headings which is usually used for display of tabular data.

:ref:`wx.HeaderCtrlSimple`  is a concrete header control which can be used directly, without inheriting from it as you need to do when using :ref:`wx.HeaderCtrl`  itself.

Event class representing the events generated by :ref:`wx.HeaderCtrl`.

A search control is a composite control with a search button, a text control, and a cancel button.

A radio box item is used to select one of number of mutually exclusive choices.

A radio button item is a button which usually denotes one of several mutually exclusive options.

A slider is a control with a handle which can be pulled back and forth to change the value.

A :ref:`wx.SpinButton`  has two small up and down (or left and right) arrow buttons.

This event class is used for the events generated by :ref:`wx.SpinButton`  and :ref:`wx.SpinCtrl`.

:ref:`wx.SpinCtrl`  combines :ref:`wx.TextCtrl`  and :ref:`wx.SpinButton`  in one control.

:ref:`wx.SpinCtrlDouble`  combines :ref:`wx.TextCtrl`  and :ref:`wx.SpinButton`  in one control and displays a real number.

This event class is used for the events generated by :ref:`wx.SpinCtrlDouble`.

:ref:`wx.ToggleButton`  is a button that stays pressed when clicked by the user.

:ref:`wx.BitmapToggleButton`  is a :ref:`wx.ToggleButton`  that contains a bitmap instead of text.

A :ref:`wx.ScrollBar`  is a control that represents a horizontal or vertical scrollbar.

A toolbar is a bar of buttons and/or other controls usually placed below the menu bar in a :ref:`wx.Frame`.

An info bar is a transient window shown at top or bottom of its parent window to display non-critical information to the user.

Represents the attributes (colour, font, ...) of an item of a control with multiple items such as e.g.

This class stores information about a :ref:`wx.ListCtrl`  item or column.

A list control presents lists in a number of formats: list view, report view, icon view and small icon view.

This class currently simply presents a simpler to use interface for the :ref:`wx.ListCtrl`  –  it can be thought of as a `façade`  for that complicated class.

A list event holds information about events associated with :ref:`wx.ListCtrl`  objects.

A tree control presents information as a hierarchy, with items that may be expanded to show further items.

A tree event holds information about events associated with :ref:`wx.TreeCtrl`  objects.

Base abstract class for all pickers which support an auxiliary text control.

This event class is used for the events generated by :ref:`wx.ColourPickerCtrl`.

This event class is used for the events generated by :ref:`wx.FilePickerCtrl`  and by :ref:`wx.DirPickerCtrl`.

This event class is used for the events generated by :ref:`wx.FontPickerCtrl`.

A file control event holds information about events associated with :ref:`wx.FileCtrl`  objects.

In order to use a custom popup with :ref:`wx.ComboCtrl`, an interface class must be derived from :ref:`wx.ComboPopup`.

A combo control is a generic combobox that allows totally custom popup.

:ref:`wx.Choicebook`  is a class similar to :ref:`wx.Notebook`, but uses a :ref:`wx.Choice`  control to show the labels instead of the tabs.

:ref:`wx.Listbook`  is a class similar to :ref:`wx.Notebook`  but which uses a :ref:`wx.ListCtrl`  to show the labels instead of the tabs.

:ref:`wx.Toolbook`  is a class similar to :ref:`wx.Notebook`  but which uses a :ref:`wx.ToolBar`  to show the labels instead of the tabs.

This class is an extension of the :ref:`wx.Notebook`  class that allows a tree structured set of pages to be shown in a control.

:ref:`wx.Simplebook`  is a control showing exactly one of its several pages.

:ref:`wx.VListBox`  is a ListBox-like control with the following two main differences from a regular :ref:`wx.ListBox`: it can have an arbitrarily huge number of items because it doesn't store them itself but uses the :meth:`~wx.VListBox.OnDrawItem`  callback to draw them (so it is a virtual listbox) and its items can have variable height as determined by :meth:`~wx.VListBox.OnMeasureItem`  (so it is also a listbox with the lines of variable height).

Small control showing an animation indicating that the program is currently busy performing some background task.

Class used with :meth:`~wx.TopLevelWindow.GeometrySerializer.SaveGeometry`  and :meth:`~wx.TopLevelWindow.GeometrySerializer.RestoreToGeometry`.

:ref:`wx.TopLevelWindow`  is a common base class for :ref:`wx.Dialog`  and :ref:`wx.Frame`.

A dialog box is a window with a title bar and sometimes a system menu, which can be moved around the screen.

This abstract class is the base for classes that help wxWidgets perform run-time layout adaptation of dialogs.

Event sent by :meth:`wx.Dialog.ShowWindowModal`   when the dialog closes.

This control can be used to place a directory listing (with optional files) on an arbitrary window.

Represents a custom read-only combobox inside :ref:`wx.FileDialog`.

Used with :ref:`wx.FileDialogCustomizeHook`  to add custom controls to :ref:`wx.FileDialog`.

Base class for customization hooks used with :ref:`wx.FileDialog`.

A frame is a window whose size and position can (usually) be changed by the user.

This class represents a dialog that shows a single or multi-line message, with a choice of ``wx.OK``, Yes, No and Cancel buttons.

Extension of :ref:`wx.MessageDialog`  with additional functionality.

This class represents a dialog that shows a short message and a progress bar.

If supported by the platform this class will provide the platform's native progress dialog, else it will simply be the  ` :ref:`wx.GenericProgressDialog` ` .

A special kind of top level window used for popup menus, combobox popups and such.

A :ref:`wx.PopupWindow`  which disappears automatically when the user clicks mouse outside it or if it loses focus in any other way.

This class holds a variety of information related to colour dialogs.

This event class is used for the events generated by :ref:`wx.ColourDialog`.

This class represents a dialog that shows a list of strings, and allows the user to select one or more.

This class represents a dialog that shows a list of strings, and allows the user to select one.

:ref:`wx.FindReplaceData`  holds the data for :ref:`wx.FindReplaceDialog`.

:ref:`wx.FindReplaceDialog`  is a standard modeless dialog which is used to allow the user to search for some text (and possibly replace it with something else).

An MDI client window is a child of :ref:`wx.MDIParentFrame`, and manages zero or more :ref:`wx.MDIChildFrame`  objects.

An MDI (Multiple Document Interface) parent frame is a window which can contain MDI child frames in its client area which emulates the full desktop.

An MDI child frame is a frame that can only exist inside a :ref:`wx.MDIClientWindow`, which is itself a child of :ref:`wx.MDIParentFrame`.

This class holds a variety of information related to font dialogs.

A listbox-like control allowing the user to rearrange the items and to enable or disable them.

A composite control containing a :ref:`wx.RearrangeList`  and the buttons allowing to move the items in it.

This class represents a dialog that requests a one-line text string from the user.

This class represents a dialog that requests a one-line password string from the user.

This class represents a dialog that requests a numeric input from the user.

The power events are generated when the system power state changes, e.g.

Helper functions for acquiring and releasing the given power resource.

Helper ``RAII`` class ensuring that power resources are released.

This class disables all top level windows of the application (maybe with the exception of one of them) in its constructor and enables them back in its destructor.

This class makes it easy to tell your user that the program is temporarily busy.

The objects of this class are used in conjunction with the :ref:`wx.Execute`  function.

A process event is sent to the :ref:`wx.EvtHandler`  specified to :ref:`wx.Process`  when a process is terminated.

:ref:`wx.UIActionSimulator`  is a class used to simulate user interface actions such as a mouse click or a key press.

:ref:`wx.SingleInstanceChecker`  class allows checking that only a single instance of a program is running.

This is the abstract base class a family of classes by which applications may invoke a help viewer to provide on-line help.

:ref:`wx.HelpProvider`  is an abstract class used by a program implementing context-sensitive help to show the help text for the given window.

:ref:`wx.SimpleHelpProvider`  is an implementation of :ref:`wx.HelpProvider`  which supports only plain text help strings, and shows the string associated with the control (if any) in a tooltip.

:ref:`wx.HelpControllerHelpProvider`  is an implementation of :ref:`wx.HelpProvider`  which supports both context identifiers and plain text help strings.

This class changes the cursor to a query and puts the application into a 'context-sensitive help mode'.

Instances of this class may be used to add a question mark button that when pressed, puts the application into context-help mode.

:ref:`wx.SystemSettings`  allows the application to ask for details about the system.

:ref:`wx.SystemOptions`  stores option/value pairs that wxWidgets itself or applications can use to alter behaviour at run-time.

:ref:`wx.ArtProvider`  class is used to customize the look of wxWidgets application.

This class is used when you wish to drag an object on the screen, and a simple cursor is not enough.

This is the default implementation of the preview control bar, a panel with buttons and a zoom control.

A preview canvas is the default canvas used by the print preview system to display the preview.

This class provides the default method of managing the print preview interface.

This class represents the Windows or PostScript printer, and is the vehicle through which printing may be launched by an application.

This class encapsulates the functionality of printing out an application document.

The dialog created by default by the print framework that enables aborting the printing process.

This class allows the application to retrieve information about all known MIME types from a system-specific location and the filename extensions to the MIME types and vice versa.

A caret is a blinking cursor showing the position where the typed text will appear.

:ref:`wx.FontEnumerator`  enumerates either all available fonts on the system or only the ones with given attributes - either only fixed-width (suited for use in programs such as terminal emulators and the like) or the fonts available in the given encoding).

:ref:`wx.FontMapper`  manages user-definable correspondence between logical font names and the fonts present on the machine.

Helper for handling mouse input events in windows containing multiple items.

The :ref:`wx.FileHistory`  encapsulates a user interface convenience, the list of most recently visited files as shown on a menu (usually the File menu).

:ref:`wx.Command`  is a base class for modelling an application command, which is an action usually performed by selecting a menu item, pressing a toolbar button or any other means provided by the application to change the data or view.

:ref:`wx.CommandProcessor`  is a class that maintains a history of Commands, with undo/redo functionality built-in.

The :ref:`wx.FileSystemWatcher`  class allows receiving notifications of file system changes.

Specialization of :ref:`wx.PreferencesPage`  useful for certain commonly used preferences page.

:ref:`wx.dataview.DataViewItem`  is a small opaque class that represents an item in a :ref:`wx.dataview.DataViewCtrl`  in a persistent way, i.e.

This class is used to indicate to a :ref:`wx.dataview.DataViewCtrl`  that a certain item (see :ref:`wx.dataview.DataViewItem`) has extra font attributes for its renderer.

:ref:`wx.dataview.DataViewIconText`  is used by :ref:`wx.dataview.DataViewIconTextRenderer`  for data transfer.

A :ref:`wx.dataview.DataViewModelNotifier`  instance is owned by a :ref:`wx.dataview.DataViewModel`  and mirrors its notification interface.

:ref:`wx.dataview.DataViewModel`  is the base class for all data model to be displayed by a :ref:`wx.dataview.DataViewCtrl`.

Base class with abstract API for :ref:`wx.dataview.DataViewIndexListModel`  and :ref:`wx.dataview.DataViewVirtualListModel`.

:ref:`wx.dataview.DataViewIndexListModel`  is a specialized data model which lets you address an item by its position (row) rather than its :ref:`wx.dataview.DataViewItem`  (which you can obtain from this class).

:ref:`wx.dataview.DataViewVirtualListModel`  is a specialized data model which lets you address an item by its position (row) rather than its :ref:`wx.dataview.DataViewItem`  and as such offers the exact same interface as :ref:`wx.dataview.DataViewIndexListModel`.

This class is used by :ref:`wx.dataview.DataViewCtrl`  to render the individual cells.

You need to derive a new class from :ref:`wx.dataview.DataViewCustomRenderer`  in order to write a new renderer.

:ref:`wx.dataview.DataViewTextRenderer`  is used for rendering text.

The :ref:`wx.dataview.DataViewIconTextRenderer`  class is used to display text with a small icon next to it as it is typically done in a file manager.

This renderer class shows a checkbox in addition to the icon and text shown by the base class and also allows the user to toggle this checkbox.

This class is used by :ref:`wx.dataview.DataViewCtrl`  to render progress bars.

This class is used by :ref:`wx.dataview.DataViewCtrl`  to render toggle controls.

A :ref:`wx.dataview.DataViewCtrl`  renderer using :ref:`wx.Choice`  control and values of strings in it.

This class is used by :ref:`wx.dataview.DataViewCtrl`  to render calendar controls.

This class is used by :ref:`wx.dataview.DataViewCtrl`  to render bitmaps.

This class represents a column in a :ref:`wx.dataview.DataViewCtrl`.

:ref:`wx.dataview.DataViewCtrl`  is a control to display data either in a tree like fashion or in a tabular form or both.

This is the event class for the :ref:`wx.dataview.DataViewCtrl`  notifications.

This class can be used with :meth:`wx.dataview.DataViewRenderer.SetValueAdjuster`   to customize rendering of model values with standard renderers.

This class is a :ref:`wx.dataview.DataViewCtrl`  which internally uses a :ref:`wx.dataview.DataViewListStore`  and forwards most of its API to that class.

:ref:`wx.dataview.DataViewListStore`  is a specialised :ref:`wx.dataview.DataViewModel`  for storing a simple table of data.

This class is a :ref:`wx.dataview.DataViewCtrl`  which internally uses a :ref:`wx.dataview.DataViewTreeStore`  and forwards most of its API to that class.

:ref:`wx.dataview.DataViewTreeStore`  is a specialised :ref:`wx.dataview.DataViewModel`  for storing simple trees very much like :ref:`wx.TreeCtrl`  does and it offers a similar API.

This class provides a mechanism for mapping between Python objects and the

A convenience class that is a :class:`DataViewModel` combined with an object mapper.

Unique identifier of an item in :ref:`wx.dataview.TreeListCtrl`.

Class defining sort order for the items in :ref:`wx.dataview.TreeListCtrl`.

A control combining :ref:`wx.TreeCtrl`  and :ref:`wx.ListCtrl`  features.

A class representing a rich text dimension, including units and position.

Manages quick access to a pool of fonts for rendering rich text.

A class for passing information to drawing and measuring functions.

This class implements a floating or inline text box, containing paragraphs.

This class implements the general concept of a field, an object that represents additional functionality such as a footnote, a bookmark, a page number, a table of contents, and so on.

A field type that can handle fields with text or bitmap labels, with a small range of styles for implementing rectangular fields and fields that can be used for start and end tags.

This object represents a line in a paragraph, and stores offsets from the start of the paragraph representing the start and end positions of the line.

This object represents a single paragraph containing various objects such as text content, images, and further paragraph layout objects.

This class stores information about an image, in binary in-memory form.

This is a kind of paragraph layout box, used to represent the whole buffer.

:ref:`wx.richtext.RichTextCell`  is the cell in a table, in which the user can type.

:ref:`wx.richtext.RichTextTable`  represents a table with arbitrary columns and rows.

A class for specifying an object anywhere in an object hierarchy, without using a pointer, necessary since ``RTC`` commands may delete and recreate sub-objects so physical object addresses change.

:ref:`wx.richtext.RichTextContextMenuPropertiesInfo`  keeps track of objects that appear in the context menu, whose properties are available to be edited.

:ref:`wx.richtext.RichTextCtrl`  provides a generic, ground-up implementation of a text control capable of showing multiple styles and images.

This is the event class for :ref:`wx.richtext.RichTextCtrl`  notifications.

Handles HTML output (only) for :ref:`wx.richtext.RichTextCtrl`  content.

A handler for loading and saving content in an ``XML`` format specific to :ref:`wx.richtext.RichTextBuffer`.

This class represents header and footer data to be passed to the :ref:`wx.richtext.RichTextPrinting`  and :ref:`wx.richtext.RichTextPrintout`  classes.

This class implements print layout for :ref:`wx.richtext.RichTextBuffer`.

This class provides a simple interface for performing :ref:`wx.richtext.RichTextBuffer`  printing and previewing.

This class incorporates a :ref:`wx.richtext.RichTextStyleListBox`  and a choice control that allows the user to select the category of style to view.

This is a listbox that can display the styles in a :ref:`wx.richtext.RichTextStyleSheet`, and apply the selection to an associated :ref:`wx.richtext.RichTextCtrl`.

This is a combo control that can display the styles in a :ref:`wx.richtext.RichTextStyleSheet`, and apply the selection to an associated :ref:`wx.richtext.RichTextCtrl`.

This class represents a paragraph style definition, usually added to a :ref:`wx.richtext.RichTextStyleSheet`.

This class represents a character style definition, usually added to a :ref:`wx.richtext.RichTextStyleSheet`.

This class represents a list style definition, usually added to a :ref:`wx.richtext.RichTextStyleSheet`.

A style sheet contains named paragraph and character styles that make it easy for a user to apply combinations of attributes to a :ref:`wx.richtext.RichTextCtrl`.

This class shows a style sheet and allows the user to edit, add and remove styles.

:ref:`wx.richtext.SymbolPickerDialog`  presents the user with a choice of fonts and a grid of available characters.

This class provides pages for :ref:`wx.richtext.RichTextFormattingDialog`, and allows other customization of the dialog.

This dialog allows the user to edit a character and/or paragraph style.

:ref:`wx.media.MediaCtrl`  is a class for displaying various types of media, such as videos, audio files, natively through native codecs.

A simple class that contains the URL and title of an element of the history of a :ref:`wx.html2.WebView`.

The base class for handling custom schemes in :ref:`wx.html2.WebView`, for example to allow virtual file system support.

A custom handler for the file scheme which also supports loading from archives.

A :ref:`wx.html2.WebView`  file system handler to support standard :ref:`wx.FileSystem`  protocols of the form  ``example:page.htm``   The handler allows  :ref:`wx.html2.WebView`  to use :ref:`wx.FileSystem`  in a similar fashion to its use with Html.

This control may be used to render web (HTML / CSS / javascript) documents.

A navigation event holds information about events associated with :ref:`wx.html2.WebView`  objects.

An abstract factory class for creating :ref:`wx.html2.WebView`  backends.

The helper struct uses as a result type for difference functions of  :ref:`wx.grid.GridBlockCoords`  class.

Represents a collection of grid blocks that can be iterated over.

This class is responsible for actually drawing the cell in the grid.

This class may be used to format string data in a cell; it is the default for string cells.

This class may be used to render in a cell a number as a textual equivalent.

Represents the result of :meth:`wx.grid.GridCellEditor.TryActivate` .

Represents a source of cell activation, which may be either a user event (mouse or keyboard) or the program itself.

This class is responsible for providing and manipulating the in-place edit controls for the grid.

Grid cell editor for string data providing the user a choice from a list of strings.

Grid cell editor which displays an enum number as a textual equivalent (e.g.

Allows to specify the behaviour when the cell contents doesn't fit into its allotted space.

This class can be used to alter the cells' appearance in the grid by changing their attributes from the defaults.

Message class used by the grid table to send requests and notifications to the grid view.

Simplest type of data table for a grid for small tables of strings that are stored in memory.

:ref:`wx.grid.GridSizesInfo`  stores information about sizes of all :ref:`wx.grid.Grid`  rows or columns.

:ref:`wx.grid.Grid`  and its related classes are used for displaying and editing tabular data.

This small class can be used to prevent :ref:`wx.grid.Grid`  from redrawing during its lifetime by calling :meth:`wx.grid.Grid.BeginBatch`   in its constructor and :meth:`wx.grid.Grid.EndBatch`   in its destructor.

This event class contains information about various grid events.

This event class contains information about a row/column resize event.

Events of this class notify about a range of cells being selected.

:ref:`wx.aui.AuiManager`  is the central class of the ``AUI`` class framework.

:ref:`wx.aui.AuiPaneInfo`  is part of the ``AUI`` class framework.

Event used to indicate various actions taken with :ref:`wx.aui.AuiManager`.

:ref:`wx.aui.AuiDockArt`  is part of the ``AUI`` class framework.

:ref:`wx.aui.AuiToolBarItem`  is part of the ``AUI`` class framework, representing a toolbar element.

:ref:`wx.aui.AuiToolBarArt`  is part of the ``AUI`` class framework.

:ref:`wx.aui.AuiDefaultToolBarArt`  is part of the ``AUI`` class framework.

:ref:`wx.aui.AuiToolBar`  is a dockable toolbar, part of the ``AUI`` class framework.

:ref:`wx.aui.AuiToolBarEvent`  is used for the events generated by :ref:`wx.aui.AuiToolBar`.

:ref:`wx.aui.AuiNotebook`  is part of the ``AUI`` class framework, which represents a notebook control, managing multiple windows with associated tabs.

A simple class which holds information about the notebook's pages and their state.

A simple class which holds information about :ref:`wx.aui.AuiNotebook`  tab buttons and their state.

:ref:`wx.aui.AuiTabContainer`  is a class which contains information about each tab.

Tab art provider defines all the drawing functions used by :ref:`wx.aui.AuiNotebook`.

Another standard tab art provider for :ref:`wx.aui.AuiNotebook`.

This class is used by the events generated by :ref:`wx.aui.AuiNotebook`.

:ref:`wx.adv.AboutDialogInfo`  contains information shown in the standard `About`  dialog displayed by the :ref:`wx.adv.AboutBox`  function.

Objects of this class are similar in appearance to the normal Buttons but are similar to the links in a web page in functionality.

This event class holds information about a date change and is used together with :ref:`wx.adv.DatePickerCtrl`.

The :ref:`wx.adv.CalendarEvent`  class is used together with :ref:`wx.adv.CalendarCtrl`.

:ref:`wx.adv.CalendarDateAttr`  is a custom attributes for a calendar date.

This event class is used for the events generated by :ref:`wx.adv.HyperlinkCtrl`.

This is the class used together with :ref:`wx.adv.ShowTip`  function.

This class represents a short sound (loaded from Windows ``WAV`` file), that can be stored in memory and played.

:ref:`wx.adv.Joystick`  allows an application to control one or more joysticks.

The  :ref:`wx.adv.Animation`  class handles the interface between the animation control and the details of the animation image or data.

Generic implementation of :ref:`wx.adv.AnimationCtrl`  interface.

:ref:`wx.adv.AnimationDecoder`  is used by  :ref:`wx.adv.Animation`  for loading frames and other information for the animation from the animation image file.

An editable listbox is composite control that lets the user easily enter, delete and reorder a list of strings.

:ref:`wx.adv.SplashScreen`  shows a window with a thin border, displaying a bitmap describing your application.

:ref:`wx.adv.SashWindow`  allows any of its edges to have a sash which can be dragged to resize the window.

A sash event is sent when the sash of a :ref:`wx.adv.SashWindow`  has been dragged by the user.

:ref:`wx.adv.LayoutAlgorithm`  implements layout of subwindows in MDI or SDI frames.

:ref:`wx.adv.SashLayoutWindow`  responds to OnCalculateLayout events generated by :ref:`wx.adv.LayoutAlgorithm`.

This event is sent when :ref:`wx.adv.LayoutAlgorithm`  wishes to get the size, orientation and alignment of a window.

This event is sent by :ref:`wx.adv.LayoutAlgorithm`  to calculate the amount of the remaining client area that the window should occupy.

:ref:`wx.adv.OwnerDrawnComboBox`  is a combobox with owner-drawn list items.

Allows showing a tool tip with more customizations than :ref:`wx.ToolTip`.

:ref:`wx.adv.WizardPage`  is one of the screens in :ref:`wx.adv.Wizard`: it must know what are the following and preceding pages (which may be ``None`` for the first/last page).

:ref:`wx.adv.WizardPageSimple`  is the simplest possible :ref:`wx.adv.WizardPage`  implementation: it just returns the pointers given to its constructor from :meth:`wx.adv.WizardPage.GetNext`   and :meth:`wx.adv.WizardPage.GetPrev`   functions.

:ref:`wx.adv.Wizard`  is the central class for implementing 'wizard-like' dialogs.

:ref:`wx.adv.WizardEvent`  class represents an event generated by the :ref:`wx.adv.Wizard`: this event is first sent to the page itself and, if not processed there, goes up the window hierarchy as usual.

This class represents a property sheet dialog: a tabbed dialog for showing settings.

:ref:`wx.ribbon.RibbonControl`  serves as a base class for all controls which share the ribbon characteristics of having a ribbon art provider, and (optionally) non-continuous resizing.

Container for related ribbon panels, and a tab within a ribbon bar.

Event used to indicate various actions relating to a :ref:`wx.ribbon.RibbonPanel`.

Event used to indicate various actions relating to a :ref:`wx.ribbon.RibbonBar`.

:ref:`wx.ribbon.RibbonArtProvider`  is responsible for drawing all the components of the ribbon interface.

Event used to indicate various actions relating to a button on a :ref:`wx.ribbon.RibbonButtonBar`.

A ribbon gallery is like a :ref:`wx.ListBox`, but for bitmaps rather than strings.

A ribbon tool bar is similar to a traditional toolbar which has no labels.

Selection state is passed to :meth:`wx.html.HtmlCell.Draw`   so that it can render itself differently e.g.

:ref:`wx.html.HtmlSelection`  is data holder with information about text selection.

This class contains information given to cells when drawing them.

The :ref:`wx.html.HtmlContainerCell`  class is an implementation of a cell that may contain more cells in it.

This class stores all necessary information about hypertext links (as represented by <A> tag in HTML documents).

This cell changes the colour of either the background or the foreground.

:ref:`wx.html.HtmlWidgetCell`  is a class that provides a connection between HTML cells and widgets (an object derived from :ref:`wx.Window`).

This html cell represents a single word or text fragment in the document stream.

:ref:`wx.html.HtmlWordCell`  is a specialization for storing text fragments with embedded tab characters.

This class is the parent class of input filters for :ref:`wx.html.HtmlWindow`.

Classes derived from this handle the **generic**  parsing of HTML documents: it scans the document and divide it into blocks of tags (where one block consists of beginning and ending tag and of text between these two tags).

Abstract interface to a HTML rendering window (such as :ref:`wx.html.HtmlWindow`  or :ref:`wx.html.HtmlListBox`) that is passed to :ref:`wx.html.HtmlWinParser`.

:ref:`wx.html.HtmlWindow`  is probably the only class you will directly use unless you want to do something special (like adding new tag handlers or MIME filters).

This event class is used for the events generated by :ref:`wx.html.HtmlWindow`.

This class can render HTML document into a specified area of a DC.

This class provides very simple interface to printing architecture.

This is basically :ref:`wx.html.HtmlTagHandler`  except that it is extended with protected member m_WParser pointing to the :ref:`wx.html.HtmlWinParser`  object (value of this member is identical to :ref:`wx.html.HtmlParser`'s m_Parser).

This class is derived from :ref:`wx.html.HtmlParser`  and its main goal is to parse HTML input so that it can be displayed in :ref:`wx.html.HtmlWindow`.

This class is used by :ref:`wx.html.HtmlHelpController`  and :ref:`wx.html.HtmlHelpFrame`  to access HTML help items.

This class is used by :ref:`wx.html.HtmlHelpController`  to display help.

This class is used by :ref:`wx.html.HtmlHelpController`  to display help within a frame or dialog, but you can use it yourself to create an embedded HTML help window.

This help controller provides an easy way of displaying HTML help in your application (see :ref:`HTML Sample <html sample>`, test example).

This class uses :ref:`wx.html.HtmlHelpController`  to display help in a modal dialog.

:ref:`wx.html.HtmlListBox`  is an implementation of :ref:`wx.VListBox`  which shows HTML content in the listbox rows.

:ref:`wx.html.SimpleHtmlListBox`  is an implementation of :ref:`wx.html.HtmlListBox`  which shows HTML content in the listbox rows.

Base class for :ref:`wx.propgrid.PropertyGrid`  cell information.

:ref:`wx.propgrid.PGAttributeStorage`  is somewhat optimized storage for key=variant pairs (i.e.

:ref:`wx.propgrid.PGProperty`  is base class for all :ref:`wx.propgrid.PropertyGrid`  properties and as such it is not intended to be instantiated directly.

Helper class for managing choices of :ref:`wx.propgrid.PropertyGrid`  properties.

Derive a class from this to adapt an existing editor dialog or function to be used when editor button of a property is pushed.

This class can be used to have multiple buttons in a property editor.

Contains low-level property page information (properties, column widths, etc.) of a single :ref:`wx.propgrid.PropertyGrid`  or single :ref:`wx.propgrid.PropertyGridPage`.

Most of the shared property manipulation interface shared by :ref:`wx.propgrid.PropertyGrid`, :ref:`wx.propgrid.PropertyGridPage`, and :ref:`wx.propgrid.PropertyGridManager`  is defined in this class.

Used to convey validation information to and from functions that actually perform validation.

:ref:`wx.propgrid.PropertyGrid`  is a specialized grid for editing properties - in other words name = value pairs.

A property grid event holds information about events associated with :ref:`wx.propgrid.PropertyGrid`  objects.

Allows populating :ref:`wx.propgrid.PropertyGrid`  from arbitrary text source.

Creates and manages a temporary :ref:`wx.TextCtrl`  for validation purposes.

This is an abstract class which serves as a base class for numeric properties, like :ref:`wx.propgrid.IntProperty`, :ref:`wx.propgrid.UIntProperty`, :ref:`wx.propgrid.FloatProperty`.

:ref:`wx.propgrid.EnumProperty`  with :ref:`String`  value and writable combo box editor.

This is an abstract class which serves as a base class for the properties having a button triggering an editor dialog, like e.g.

Like :ref:`wx.propgrid.LongStringProperty`, but the button triggers file selector instead.

Like :ref:`wx.propgrid.StringProperty`, but has a button that triggers a small text editor dialog.

Like :ref:`wx.propgrid.LongStringProperty`, but the button triggers directory selector instead.

Because text, background and other colours tend to differ between platforms, :ref:`wx.propgrid.SystemColourProperty`  must be able to select between system colour and, when necessary, to pick a custom one.

Property that manages a value resulting from :ref:`wx.MultiChoiceDialog`.

:ref:`wx.propgrid.PropertyGridManager`  is an efficient multi-page version of :ref:`wx.propgrid.PropertyGrid`, which can optionally have toolbar for mode and page selection, a help text box, and a header.

SwitcherDialog shows a :class:`Dialog` with a list of panes and tabs for the user to choose.

This class handles the creation of a custom image in case of drag and drop of a notebook tab.

Toolbar art provider code - a tab provider provides all drawing functionality to the :class:`AuiToolBar`.

AuiToolBar is a completely owner-drawn toolbar perfectly integrated with the AUI layout system.

A specialized command event class for events sent by :class:`AuiToolBar`.

AuiNotebook is a notebook control which implements many features common in applications with dockable panes.

A specialized command event class for events sent by :class:`AuiNotebook`.

A simple class which holds information about tab captions, bitmaps and

AuiTabContainer is a class which contains information about each tab.

A simple class which holds information about tab buttons and their state.

This is an actual :class:`wx.Window` - derived window which can be used as a tab control in the normal sense.

A specialized command event class for events sent by :class:`AuiNotebook` .

TabFrame is an interesting case. It's important that all child pages

Data storage class for managing and providing access to :class:`TabNavigatorWindow` properties.

This class is used to create a modal dialog that enables "Smart Tabbing",

Dock art provider code - a dock provider provides all drawing functionality to the AUI dock manager.

ModernDockArt is a custom `AuiDockArt` class, that implements a look similar to Firefox and other recents applications.

A docking guide window for multiple docking hint (diamond-shaped HUD).

Base class for :class:`AuiSingleDockingGuide` and :class:`AuiCenterDockingGuide`.

A class which holds information about VS2005 docking guide windows.

Target class for :class:`AuiDockingGuide` and :class:`AuiCenterDockingGuide`.

AuiManager manages the panes associated with it for a particular :class:`wx.Frame`,

A class similar to :class:`AuiManager` but with a Dummy Center Pane (**DCP**).

A specialized command event class for events sent by :class:`AuiManager`.

A simple class which describes the caption pane button attributes.

AuiPaneInfo specifies all the parameters for a pane. These parameters specify where

A docking guide window for single docking hint (not diamond-shaped HUD).

Tab art provider code - a tab provider provides all drawing functionality to the :class:`~wx.lib.agw.aui.auibook.AuiNotebook`.

Base class for persistent windows, uses the window name as persistent name by

Supports saving/restoring :class:`lib.agw.aui.framemanager.AuiManager` perspectives.

Supports saving/restoring checked and selected items in :class:`CheckListBox`.

Supports saving/restoring :class:`Choice`, :class:`ComboBox` and :class:`adv.OwnerDrawnComboBox`

Supports saving/restoring a :class:`MultiChoiceDialog` / :class:`SingleChoiceDialog` choices.

Supports saving/restoring a :class:`CollapsiblePane` / :class:`lib.agw.pycollapsiblepane.PyCollapsiblePane` state.

Supports saving/restoring a :class:`wx.ColourDialog` data (colour, custom colours and full

Supports saving/restoring a :class:`wx.ColourPickerCtrl` / :class:`lib.colourselect.ColourSelect` colour.

Supports saving/restoring a :class:`DirDialog` / :class:`FileDialog` path.

Supports saving/restoring a :class:`FilePickerCtrl` / :class:`DirPickerCtrl` path.

Supports saving/restoring a :class:`FileHistory` list of file names.

Supports saving/restoring a :class:`FindReplaceDialog` data (search string, replace string

Supports saving/restoring of :class:`lib.agw.foldpanelbar.FoldPanelBar`.

Supports saving/restoring a :class:`wx.FontDialog` data (effects, symbols, colour, font, help).

Supports saving/restoring selected items in :class:`ListBox`, :class:`ListCtrl`, :class:`ListView`,

Supports saving/restoring selected items and column sizes in :class:`ListCtrl`.

Supports saving/restoring a :class:`media.MediaCtrl` movie position, volume and playback

Supports saving/restoring the :class:`wx.MenuBar` and :class:`lib.agw.flatmenu.FlatMenuBar` items state.

Supports saving/restoring a :class:`ScrolledWindow` / :class:`lib.scrolledpanel.ScrolledPanel`

Supports saving/restoring a :class:`Slider` / :class:`lib.agw.knobctrl.KnobCtrl` thumb position.

Supports saving/restoring a :class:`SpinButton` / :class:`SpinCtrl` value.

Supports saving/restoring a :class:`SplitterWindow` splitter position.

Supports saving/restoring a :class:`ToggleButton` and friends state.

Supports saving/restoring the :class:`lib.agw.aui.auibar.AuiToolBar` items state.

Supports saving/restoring a :class:`TreeCtrl` expansion state, selections and

Supports saving/restoring a :class:`lib.agw.hypertreelist.HyperTreeList` expansion state,

:class:`PersistenceManager`: global aspects of persistent windows.

Event used to indicate various actions relating to a :class:`RibbonBar`.

Event used to indicate various actions relating to a button on a :class:`RibbonButtonBar`.

A ribbon gallery is like a :class:`ListBox`, but for bitmaps rather than strings.

:class:`AdvancedSplash` tries to reproduce the behavior of :class:`~adv.SplashScreen`, with

A mixin that allows to transform :class:`AquaButton` in the corresponding toggle button.

Event sent from the :class:`AquaButton` buttons when the button is activated.

This class provides various art utilities, such as creating shadow, providing

This class is called by the main :class:`BalloonTip` class, and it is

:class:`BalloonTip` is a class that allows you to display tooltips in a balloon style

:class:`BPArt` is an art provider class which does all of the drawing for :class:`ButtonPanel`.

This class holds information about every button that is added to

A custom panel class with gradient background shading with the possibility to

This class is used to hold data about the main caption in :class:`ButtonPanel`.

This class represents a base class for all pseudo controls used in

This class holds all the information to size and draw a separator inside

This is a mix-in class to add pseudo support to :class:`wx.Sizer`. Just create

Timer used for deleting :class:`StatusBar` long help after ``_DELAY`` seconds.

Implements the drawing, mouse handling and sizing routines for the alpha

Base class used to hold common code for the Alpha channel control and the

Base class used to hold common code for the HSB colour wheel and the RGB

Implements the drawing, mouse handling and sizing routines for the brightness

This is a subclass of :class:`wx.Colour`, which adds Hue, Saturation and Brightness

Simple custom class used to display "old" and "new" colour panels, with alpha

This panel displays a series of custom colours (chosen by the user) just like

Implements the drawing, mouse handling and sizing routines for the HSV

Simple class to store description and constants for a line in 2D space.

Implements the drawing, mouse handling and sizing routines for the RGB

:class:`CommandTreeEvent` is a special subclassing of :class:`CommandEvent`.

:class:`CustomTreeCtrl` is a class that mimics the behaviour of :class:`TreeCtrl`, with almost the

This class handles the creation of a custom image in case of item drag

This class holds all the information and methods for every single item in

:class:`CommandTreeEvent` is a special class for all events associated with tree controls.

Timer used to clear the :class:`CustomTreeCtrl` `_findPrefix` attribute if no

Creates the item attributes (text colour, background colour and font).

The :class:`FileHistory` encapsulates a user interface convenience, the list of most

Implements the generic owner-drawn menu bar for :class:`FlatMenu`.

Base class for generic flat menu derived from :class:`PopupWindow`.

A nice small class that functions like :class:`wx.BitmapButton`, the reason I did

Event class that supports the :class:`FlatMenu`-compatible event called

Base class for the :class:`FlatMenu` renderers. This class implements the common

This class represents a manager that handles all the renderers defined.

Since Max OS does not support :class:`PopupWindow`, this is an alternative.

Base class for generic :class:`FlatMenu` derived from :class:`PopupWindow`.

The :class:`FlatNotebook` is a full implementation of the :class:`Notebook`, and designed to be

This class is more compatible with the :class:`Notebook` API, especially regarding

This event will be sent when a ``EVT_FLATNOTEBOOK_PAGE_DRAGGED_FOREIGN`` is

This events will be sent when a ``EVT_FLATNOTEBOOK_PAGE_CHANGED``,

Stores all the information to allow drag and drop between different

Give some custom UI feedback during the drag and drop operation in this

Class used to handle the :meth:`FlatNotebook.OnDropTarget() <FlatNotebook.OnDropTarget>` method when dragging and

Parent class for the 6 renderers defined: `Standard`, `VC71`, `Fancy`, `Firefox 2`,

This class handles the drawing of tabs using the standard renderer.

This class handles the drawing of tabs using the `Fancy` renderer.

This class handles the drawing of tabs using the `Firefox 2` renderer.

This class represents a manager that handles all the 6 renderers defined

This class handles the drawing of tabs using the `Ribbon Tabs` renderer.

This class handles the drawing of tabs using the `VC71` renderer.

This class handles the drawing of tabs using the `VC8` renderer.

This class acts as a container for the pages you add to :class:`FlatNotebook`.

This class holds all the information (caption, image, etc...) belonging to a

This class is used to create a modal dialog that enables `Smart Tabbing`,

FixedPoint objects support decimal arithmetic with a fixed number of

:class:`FloatSpin` implements a floating point :class:`SpinCtrl`. It is built using a custom

This event will be sent when a ``EVT_FLOATSPIN`` event is mapped in the parent.

A class which holds a :class:`TextCtrl`, one of the two building blocks

Class used to customize the appearance of :class:`~wx.lib.agw.flatmenu.FlatMenu`

This event will be sent when a ``EVT_CAPTIONBAR`` is mapped in the parent.

The :class:`FoldPanelBar` is a class which can maintain a list of

This class is a child sibling of the :class:`FoldPanelBar` class. It will

This class is a child sibling of the :class:`FoldPanelItem` class. It

This class is very similar to :class:`SplitterWindow` except that it

This event class is almost the same as :class:`SplitterEvent` except

Main class implementation, :class:`GenericMessageDialog` is a possible replacement

This is the main class implementation of :class:`GradientButton`.

Event sent from :class:`GradientButton` when the button is activated.

:class:`HyperLinkCtrl` is a control for wxPython that acts like a hyper

Event object sent in response to clicking on a :class:`HyperLinkCtrl`.

:class:`HyperTreeList` is a generic widget that combines the multicolumn

Class used to store information (width, alignment flags, colours, etc...) about a

This class represents the main window (and thus the main column) in :class:`HyperTreeList`.

A simple class derived from :mod:`lib.stattext` that implements auto-wrapping

An info bar is a transient window shown at top or bottom of its parent window to display

This class can be used to simulate a knob volume control often found in

Represent details of the events that the :class:`KnobCtrl` object sends.

Base class for the containing window for :class:`LabelBook` and :class:`FlatImageBook`.

Default implementation of the image book, it is like a :class:`Notebook`, except that

This events will be sent when a ``EVT_IMAGENOTEBOOK_PAGE_CHANGED``,

An implementation of a notebook control - except that instead of having

A different implementation of :class:`DirDialog` which allows multiple

:class:`PieCtrl` is somewhat a "static" control, that you may create in order to display

This class displays a legend window for the classic :class:`PieCtrl`.

This class handles the legend segments properties, such as value,

:class:`ProgressPie` tries to emulate the behavior of :class:`ProgressDialog`, but

Constructs a busy info window as child of parent and displays a message in it.

A :class:`GTKExpander` allows the user to hide or show its child by clicking on an expander

:class:`PyCollapsiblePane` is a container with an embedded button-like control which

This class provides a visual alternative for :class:`Gauge`. It currently

:class:`PyProgress` is similar to :class:`ProgressDialog` in indeterminated mode, but with a

This class holds all the information about a single indicator inside :class:`RulerCtrl`.

Auxiliary class. Just holds information about a label in :class:`RulerCtrl`.

:class:`RulerCtrl` implements a ruler window that can be placed on top, bottom, left or right

Represent details of the events that the :class:`RulerCtrl` object sends.

This image handler loads and manipulates the thumbnails with the help of

This image handler loads and manipulates the thumbnails with the help

This is the main class implementation of :class:`ThumbnailCtrl`.

This is an auxiliary class, to handle single thumbnail information for every thumb.

This class is used to send events when a thumbnail is hovered, selected,

A mixin that allows to transform any of :class:`SButton`, :class:`SBitmapButton` and

Subclass of :class:`SButton` which displays a bitmap, acting like a

Subclass of :class:`SButton` which displays a bitmap and a label.

Event sent from the generic buttons when the button is activated.

:class:`ConflictDialog` is a subclass of :class:`GenericMessageDialog`, customized to look

A simple :class:`wx.Frame` container for the basic help provided to :class:`ShortcutEditor`.

:class:`ListShortcut` is a subclass of :class:`~wx.lib.agw.hypertreelist.HyperTreeList`,

:class:`Shortcut` is a class containing the details for a shortcut, whether from

:class:`ShortcutEditor` is a widget that allows the user to customize and change keyboard

:class:`ShortcutEvent` is a special subclassing of :class:`PyCommandEvent`.

:class:`SpeedMeter` tries to reproduce the behavior of some car controls (but not only),

The main class for :class:`SuperToolTip`, which holds all the methods

:class:`ScrolledTextDialog` is a dialog widget which displays a scrolled

:class:`ThumbnailCtrl` is a widget that can be used to display a series of images in

ToasterBox is a cross-platform widget to make the creation of MSN style "toaster"

This class does all the job, by handling background images, text properties

A simple class which holds information about :class:`UltimateListCtrl` columns.

A list event holds information about events associated with :class:`UltimateListCtrl`

A simple class which holds items geometries for :class:`UltimateListCtrl` not in

A :class:`PyImageList` contains a list of images. Images can have masks for

SelectionStore is used to store the selected items in the virtual

UltimateListCtrl is a class that mimics the behaviour of :class:`ListCtrl`, with almost

A simple class which holds information about :class:`UltimateListItem` visual

This class holds the header window for :class:`UltimateListCtrl`.

This class stores information about a :class:`UltimateListCtrl` item or column.

Represents the attributes (colour, font, ...) of a :class:`UltimateListCtrl`

A simple class which holds line geometries for :class:`UltimateListCtrl`.

This is the main widget implementation of :class:`UltimateListCtrl`.

This is a subclass of :class:`SuperToolTip` and it is used to display a

This is a class which holds information about the cell background, in terms

This is a class which holds information about a single cell border, in terms

This is a factory class which holds information about all the borders in a

This is a class which holds information about a single cell in :class:`XLSGrid`.

This is a class which holds information about the content of the "comment

:class:`XLSGrid` is a class based on :class:`grid.Grid` that can be used to faithfully

This is a class which holds information about the cell content, in terms

This class holds the background button bar on which the buttons float.

:class:`ZoomBar` is a class that *appoximatively* mimics the behaviour of the Mac Dock,

Event sent from the :class:`ZoomBar` when a button is activated.

This simple class holds information about a :class:`ZoomBar` button, such as normal

A simple derived class that provides some backwards compatibility

Adds GetColour()/GetValue() for compatibility with ColourPickerCtrl and colourselect

Class to provide a GUI Mode that makes a rubber band box that can be drawn on a Window

Mixin class for objects that have just one color, rather than a fill

An example of a Grid Object -- it is set on the FloatCanvas with one of::

Draws an ellipse see :class:`~lib.floatcanvas.FloatCanvas.RectEllipse`

Mixin class for objects that have both a line and a fill color and

Mixin class for objects that have just a line, rather than a fill

Draws a rectangle see :class:`~lib.floatcanvas.FloatCanvas.RectEllipse`

##fixme: this can be deprecated and just use ScaledTextBox with different defaults.

A mix in class that holds attributes and methods that are needed by

This is a mixin class that provides some methods suitable for use

This event class takes a regular wxWindows mouse event as a parameter,

The main class of the floatcanvas package :class:`~lib.floatcanvas.FloatCanvas`.

DynamicSashSplitEvents are sent to your view by DynamicSashWindow whenever

DynamicSashUnifyEvents are sent to your view by DynamicSashWindow whenever

A DynamicSashWindow widget manages the way other widgets are viewed. When

The LEDNumberCtrl can be used to display a series of digits, (plus spaces,

See documentation for :class:`~wx.lib.agw.hypertreelist.HyperTreeList` and

Base class for generic masked edit comboboxes; allows auto-complete of values.

This handler ensures that the derived control can react to events

Because calling SetSelection programmatically does not fire EVT_COMBOBOX

This class manages the individual fields in a masked edit control.

To avoid a ton of boiler-plate, and to automate the getter/setter generation

This class allows us to abstract the masked edit functionality that could

Used to fire an EVT_NUM event whenever the value in a NumCtrl changes.

Masked edit control supporting "native" numeric values, ie. .SetValue(3), for

This is the primary derivation from MaskedEditMixin.  It provides

Masked control providing several time formats and manipulation of time values.

Defines TimeCtrl's list of attributes having their own Get/Set functions,

Used to fire an EVT_TIMEUPDATE event whenever the value in a TimeCtrl changes.

A mix-in class that automatically enables the grid edit control when

This class can be mixed with wx.grid.Grid to add the ability to plugin

A simple mix of :class:`App` and :class:`InspectionMixin` that can be used

This class is intended to be used as a mix-in with the :class:`App`.

A mixin class that handles sorting of a wx.ListCtrl in REPORT mode when

A mix-in class that automatically resizes the last column to take up

This is a mixin class that can be used to allow for virtual tree

The :class:`CircleShape` class is an :class:`EllipseShape` whose width

The :class:`PolygonShape` class shape is defined by a number of points

The :class:`wx.RectangleShape` class has rounded or square corners.

The :class:`TextShape` class like :class:`wx.RectangleShape` but only the

The :class:`wx.BitmapShape` class draws a bitmap (non-resizable).

The :class:`CompositeShape` is a shape with a list of child objects, and a

The :class:`Constraint` class helps specify how child shapes are laid out

A :class:`DivisionShape` class is a composite with special properties,

The :class:`Diagram` encapsulates an entire diagram, with methods for

A :class:`DividedShape` is a rectangle with a number of vertical divisions.

Draws a pseudo-metafile shape, which can be loaded from a simple

Draw line, rectangle, rounded rectangle, ellipse, point, arc, text.

The LineShape class may be attached to two nodes, it may be segmented,

Generic class for describing which sides of a box are displayed.

Represent the "signature" or protocol of a listener in the context of

A simple container object for the two components of a message in the

Interface class base class for any handler given to pub.setListenerExcHandler()

Wraps a callable so it can be stored by weak reference and introspected

Manages notifications for tracing pubsub activity. When pubsub takes a

Publisher used for kwargs protocol, ie when sending message data

Mixin for publishing messages to a topic's listeners. This will be

Raised when a sendMessage() has arguments not listed among the topic's

Interface class for all topic definition de-serializers that can be

All topic definition providers added via pub.addTopicDefnProvider()

Convert a nested class tree as a topic definition tree. Format: the class

Deserialize a module containing Python source code defining a topic tree.

Deserialize a string containing Python source code defining a topic tree.

Raised when a listener exception handler (see pub.setListenerExcHandler())

Raised when an operation requires a topic have an MDS, but it doesn't.

Raised when a topic definition provider doesn't recognize the format

Stores a list of topic definition providers. When queried for a topic

Supports taking action on every topic in the topic tree. The traverse() method

Represent a weak bound method, i.e. a method which doesn't keep alive the

Example exception handler that simply publishes the exception traceback

Derive your Notifications handler from this class if your handler

Example topic tree visitor that prints a prettified representation

Create a six.moves.urllib namespace that resembles the Python 3 namespace

A class that implements Delphi's Anchors with :class:`wx.LayoutConstraints`.

This class is just like :class:`wx.BusyInfo`, except that its default

Uses the native renderer to draw the bezel, also handle mouse-overs.

A mixin that allows to transform :class:`GenButton` in the corresponding

Inherit this mixin in your :class:`wx.Window` based subclass to easily

A generic class that replicates some of the functionalities of :class:`wx.Checkbox`,

Class for a :class:`wx.html.HtmlWindow` which responds to clicks on

:class:`wx.ColourSelectEvent` is a special subclassing of :class:`wx.CommandEvent`

A simple container for tracking custom colours to be shown in the colour

BaseComboTreeBox is the base class for platform specific versions of the

BasePopupFrame is the base class for platform specific versions of the

TreeCtrl is the same as :class:`TreeCtrl`, with a few convenience methods

NativeComboTreeBox, and any subclass, uses the native ComboBox as basis,

Convenience class that represents a kind of threading.Event that

Represent the actual delayed result coming from the non-main thread.

Bind some of the arguments and keyword arguments of a callable ('listener').

Represent a 'delayed result pre-processing chain', a kind of Handler.

Base class for various kinds of senders. A sender sends a result

This sender sends the delayed result produced in the worker thread

An object that has attributes built from the dictionary given in

A dialog like :class:`wx.MessageDialog`, but with an optional 2nd message string

``Command`` is a base class for modelling an application command,

:class:`CommandProcessor` is a class that maintains a history of

The :class:`DocChildFrame` class provides a default frame for displaying

The :class:`DocManager` class is part of the document/view framework,

The :class:`DocMDIChildFrame` class provides a default frame for displaying

The :class:`DocMDIParentFrame` class provides a default top-level frame for

The :class:`DocParentFrame` class provides a default top-level frame for

DocPrintout is a default :class:`wx.Printout` that prints the first

The :class:`DocTemplate` class is used to model the relationship between a

The document class can be used to model an application's file-based data. It

The view class can be used to model the viewing and editing component of

Scrolls a wx.ScrollWindow in the direction and speed of a mouse drag.

PyEmbeddedImage is primarily intended to be used by code generated

The purpose of the AppEventHandlerMixin is to provide a centralized

Panel with CheckListBox for selecting which events will be watched.

A virtual listctrl that displays information about the watched events.

A frame that will catch and display all events sent to some widget.

This is the main class in the module, and is the only class that

A control to allow the user to type in a filename or browse with

:class:`wx.ImageDialog` derived from :class:`Dialog` allows the user

This class is the frame that holds the wxPython inspection tools.

The :class:`InspectionTool` is a singleton that manages creating and

This class provides a control that takes and returns integers as

Event sent from the :class:`~lib.intctrl.IntCtrl` when control is updated.

Validator class used with :class:`~lib.intctrl.IntCtrl` handles all validation of

ItemsPicker is a widget that allows the user to form a set of picked

:class:`wx.ListCtrl` derived control that displays languages and flags

The class Layoutf(wxLayoutConstraints) presents a simplification

This validator is used to transfer values to/from the widgets and

Control(parent, id=ID_ANY, pos=DefaultPosition, size=DefaultSize, style=0, validator=DefaultValidator, name=ControlNameStr)

Opens an AboutDialog.  Shared by DocMDIParentFrame and DocSDIFrame.

About Dialog Service that installs under the Help menu to show the properties of the current application.

A ChildDocTemplate is a DocTemplate subclass that enables the creation of ChildDocuments

A ChildDocument is a document that represents a portion of a Document.  The child

The DocApp class serves as the base class for pydocview applications and offers

Class with common code used by DocMDIParentFrame, DocTabbedParentFrame, and

The wxDocMDIChildFrame class provides a default frame for displaying

The DocMDIParentFrame is the primary frame which the DocApp uses to host MDI child windows.  It offers

Class with common code used by DocMDIParentFrame and DocTabbedParentFrame.

A service that implements an options menu item and an options dialog with

The DocSDIFrame host DocManager Document windows.  It offers features such as a default menubar,

An abstract class used to add reusable services to a docview application.

The DocTabbedParentFrame class provides a default top-level frame for

Dialog that shows the properties of a file.  Invoked by the PropertiesService.

Service that installs under the File menu to show the properties of the file associated

A general options panel that is used in the OptionDialog to configure the

A default options dialog used by the OptionsService that hosts a notebook

The WindowMenuService is a service that implements a standard Window menu that is used

Reparents a given widget into a specialized panel that provides a resize

Mix this class with :class:`App` and call :meth:`InitForUpdates` from the derived class'

This event class is almost the same as `wx.SplitterEvent` except

This class is very similar to `wx.SplitterWindow` except that it

:class:`GenStaticBitmap` is a generic implementation of :class:`wx.StaticBitmap`.

:class:`GenStaticText` is a generic implementation of :class:`wx.StaticText`.

The first argument is either the name of a file that will be split into frames

A mix-in class for frames that will have a Shell or a Crust window

A gradient is a method used to fade from one color to another, either

A Gradient stop is an offset and a color, which is used when drawing gradients.

A SVGimageBase can be created either from an SVG file or from an in-memory

This class defines how to fill or stroke a shape when rendering the SVG

An SVGpath is essentially just a collection of bezier curves, defined by a

SVGshape is a set of attributes describing how to draw one shape in the SVG,

The SVGimage class provides various ways to load and use SVG images