Annotated Class List
Qt classes with brief descriptions:
The base of all animations | |
The abstract base class of button widgets, providing functionality common to buttons | |
Interface to manage Qt's event queue | |
Interface for extension factories in Qt Designer | |
Interface for extension managers in Qt Designer | |
File icons for the QFileSystemModel class | |
Default implementation for classes that create user interfaces at run-time | |
Common base for all path items | |
Used to display and edit data items from a model | |
The abstract interface for item model classes | |
Helps testing QAbstractItemModel subclasses | |
The basic functionality for item view classes | |
Abstract model that can be subclassed to create one-dimensional list models | |
Interface for receiving native events, such as MSG or XCB event structs | |
The interface for cache implementations | |
The base of all implementations of OAuth authentication methods | |
The base of all implementations of OAuth 2 authentication methods | |
Handles replies to OAuth authentication requests | |
The base class of a family of classes that expose all functions for each OpenGL version and profile | |
Base implementation for print dialogs used to configure printers | |
Base class for proxy item models that can do sorting, filtering or other data processing tasks | |
Scrolling area with on-demand scroll bars | |
Integer value within a range | |
The base functionality common to all socket types | |
Spinbox and a line edit to display values | |
Abstract model that can be subclassed to create table models | |
Abstract base class used to implement custom layouts for QTextDocuments | |
Enums and static functions related to accessibility | |
Implements support for invocable actions in the interface | |
Implements support for objects with editable text | |
The base class for accessibility notifications | |
Defines an interface that exposes information about accessible objects | |
Implements parts of the QAccessibleInterface for QObjects | |
Abstract base class for plugins provinding accessibility information for user interface elements | |
Notfies the accessibility framework that the state of an object has changed | |
Implements support for the IAccessibleTable2 Cell interface | |
Implements support for the IAccessibleTable2 interface | |
Signifies a change in a table, list, or tree where cells are added or removed. If the change affected a number of rows, firstColumn and lastColumn will return -1. Likewise for columns, the row functions may return -1 | |
Notifies of cursor movements | |
Notifies of text being inserted | |
Implements support for text handling | |
Notifies of text being deleted | |
Signals a change in the text selection of an object | |
Notifies about text changes. This is for accessibles that support editable text such as line edits. This event occurs for example when a portion of selected text gets replaced by pasting a new text or in override mode of editors | |
Describes a change in value for an accessible object | |
Implements support for objects that manipulate a value | |
Implements the QAccessibleInterface for QWidgets | |
Abstraction for user commands that can be added to different user interface components | |
Event that is generated when a QAction is added, removed, or changed | |
Groups actions together | |
Helper tag class | |
Abstract base class for groups of animations | |
Unified view on Latin-1, UTF-8, or UTF-16 strings with a read-only subset of the QString API | |
Manages the GUI application's control flow and main settings | |
Iterable interface for an associative container in a QVariant | |
Platform-independent atomic operations on int | |
Platform-independent atomic operations on integers | |
Template class that provides platform-independent atomic operations on pointers | |
Authentication object | |
Platform-independent big-endian integers | |
Drawing area for QWindow | |
Timer events for objects | |
Array of bits | |
Monochrome (1-bit depth) pixmaps | |
Lines up child widgets horizontally or vertically | |
Defines the fill pattern of shapes drawn by QPainter | |
QIODevice interface for a QByteArray | |
Container to organize groups of button widgets | |
Array of bytes | |
List of byte arrays | |
Holds a sequence of bytes that can be quickly matched in a byte array | |
View on an array of bytes with a read-only subset of the QByteArray API | |
Template class that provides a cache | |
Describes calendar systems | |
Monthly based calendar widget allowing the user to select a date | |
Used to hold an array of CBOR elements | |
Holds the error condition found while parsing or validating a CBOR stream | |
Used to hold an associative container representable in CBOR | |
Used by QCborValue to report a parsing error | |
Simple CBOR stream decoder, operating on either a QByteArray or QIODevice | |
Simple CBOR encoder operating on a one-way stream | |
Encapsulates a value in CBOR | |
16-bit Unicode character | |
Checkbox with a text label | |
Contains event parameters for child object events | |
Access to the window system clipboard | |
Contains parameters that describe a close event | |
Compares strings according to a localized collation algorithm | |
Can be used to speed up string collation | |
Colors based on RGB, HSV or CMYK values | |
Dialog widget for specifying colors | |
Color space abstraction | |
Transformation between color spaces | |
Maps device independent QColors to device dependent pixel values | |
Model/view implementation of a column view | |
Combined button and popup list | |
Defines a possible command-line option | |
Means for handling the command line options | |
Vista style command link button | |
Encapsulates the common Look and Feel of a GUI | |
Completions based on an item model | |
Access to the details about a compressed help file | |
Proxies multiple source models, concatenating their rows | |
Used in combination with QBrush to specify a conical gradient brush | |
Allows iteration over a container in a QVariant | |
Contains parameters that describe a context menu event | |
Template class that provides a contiguous cache | |
Event loop for Qt applications without UI | |
Way to generate cryptographic hashes | |
Mouse cursor with an arbitrary shape | |
The base class of D-Bus adaptor classes | |
The base class for all D-Bus interfaces in the Qt D-Bus binding, allowing access to remote interfaces | |
Used to marshall and demarshall D-Bus arguments | |
Represents a connection to the D-Bus bus daemon | |
Access to the D-Bus bus daemon service | |
Allows slots to determine the D-Bus context of the calls | |
Represents an error received from the D-Bus bus or from remote applications found in the bus | |
Proxy for interfaces on remote objects | |
Represents one message sent or received over the D-Bus bus | |
Enables the programmer to identify the OBJECT_PATH type provided by the D-Bus typesystem | |
Refers to one pending asynchronous call | |
Convenient way for waiting for asynchronous replies | |
Contains the reply to an asynchronous method call | |
Stores the reply for a method call to a remote object | |
Peer-to-peer communication between processes on the same computer | |
Allows the user to watch for a bus service change | |
Enables the programmer to identify the SIGNATURE type provided by the D-Bus typesystem | |
Holds one Unix file descriptor | |
Enables the programmer to identify the variant type provided by the D-Bus typesystem | |
Used to handle several DBus paths with one class | |
Serialization of binary data to a QIODevice | |
Mapping between a section of a data model to widgets | |
Date functions | |
Widget for editing dates based on the QDateTimeEdit widget | |
Date and time functions | |
Widget for editing dates and times | |
Marks a deadline in the future | |
Output stream for debugging information | |
Convenience class for custom QDebug operators | |
Allows you to change the focus of Qt Designer's action editor | |
Allows you to add pages to a custom multi-page container in Qt Designer's workspace | |
Allows you to include several custom widgets in one single library | |
Enables Qt Designer to access and construct custom widgets | |
Allows you to manipulate a widget's dynamic properties in Qt Designer's property editor | |
Allows you to access Qt Designer's various components | |
Allows you to query and modify a form window's widget selection, and in addition modify the properties of all the form's widgets | |
Allows you to query and manipulate form windows appearing in Qt Designer's workspace | |
Allows you to manipulate the collection of form windows in Qt Designer, and control Qt Designer's form editing actions | |
Allows you to manipulate a widget's member functions which is displayed when configuring connections using Qt Designer's mode for editing signals and slots | |
Allows you to change the focus of Qt Designer's object inspector | |
Allows you to query and manipulate the current state of Qt Designer's property editor | |
Allows you to manipulate a widget's properties which is displayed in Qt Designer's property editor | |
Allows you to add custom menu entries to Qt Designer's task menu | |
Allows you to control the contents of Qt Designer's widget box | |
Methods for accessing common desktop services | |
Rounded range control (like a speedometer or potentiometer) | |
The base class of dialog windows | |
Widget that presents buttons in a layout that is appropriate to the current widget style | |
Access to directory structures and their contents | |
Iterator for directory entrylists | |
Stores information about a domain name record | |
Stores information about a host address record | |
Represents a DNS lookup | |
Stores information about a DNS MX record | |
Stores information about a DNS SRV record | |
Stores information about a DNS TXT record | |
Widget that can be docked inside a QMainWindow or floated as a top-level window on the desktop | |
Represents one attribute of a QDomElement | |
Represents an XML CDATA section | |
Represents a generic string in the DOM | |
Represents an XML comment | |
Represents an XML document | |
Tree of QDomNodes which is not usually a complete QDomDocument | |
The representation of the DTD in the document tree | |
Represents one element in the DOM tree | |
Represents an XML entity | |
Represents an XML entity reference | |
Information about the features of the DOM implementation | |
Contains a collection of nodes that can be accessed by name | |
The base class for all the nodes in a DOM tree | |
List of QDomNode objects | |
Represents an XML notation | |
Represents an XML processing instruction | |
Represents text data in the parsed XML document | |
Spin box widget that takes doubles | |
Range checking of floating-point numbers | |
Support for MIME-based drag and drop data transfer | |
Event which is sent to a widget when a drag and drop action enters it | |
Event that is sent to a widget when a drag and drop action leaves it | |
Event which is sent while a drag and drop action is in progress | |
Event which is sent when a drag and drop action is completed | |
This class provides encryption for UDP sockets | |
This class implements server-side DTLS cookie generation and verification | |
Contains event parameters for dynamic property change events | |
Easing curves for controlling animation | |
Fast way to calculate elapsed times | |
A base class that allows obtaining a QSharedPointer for an object already managed by a shared pointer | |
Contains parameters that describe an enter event | |
Error message display dialog | |
The base class of all event classes. Event objects contain event parameters | |
Means of entering and leaving an event loop | |
Means to quit an event loop when it is no longer needed | |
Information about a point in a QPointerEvent | |
Base class for exceptions that can be transferred across threads | |
Represents a pointer to an explicitly shared object | |
Contains event parameters for expose events | |
Allows you to create a factory that is able to make instances of custom extensions in Qt Designer | |
Extension management facilities for Qt Designer | |
Interface for reading from and writing to files | |
Interface for reading from and writing to open files | |
Dialog that allow users to select files or directories | |
File icons for the QFileSystemModel class | |
System-independent file information | |
Event that will be sent when there is a request to open a file or a URL | |
Convenient way of selecting file variants | |
Data model for the local filesystem | |
Interface for monitoring files and directories for modifications | |
Helper data type for QFlags | |
Type-safe way of storing OR-combinations of enum values | |
Contains event parameters for widget focus events | |
Focus frame which can be outside of a widget's normal paintable area | |
Specifies a query for a font used for drawing text | |
Combobox that lets the user select a font family | |
Information about the fonts available in the underlying window system | |
Dialog widget for selecting a font | |
General information about fonts | |
Font metrics information | |
Font metrics information | |
Used to dynamically construct user interfaces from UI files at run-time | |
Manages forms of input widgets and their associated labels | |
The base class of widgets that can have a frame | |
Represents the result of an asynchronous computation | |
Java-style const iterator for QFuture | |
Convenience class that simplifies QFuture synchronization | |
Allows monitoring a QFuture using signals and slots | |
Internal helper class for marshalling arguments | |
Template class that represents a NxM transformation matrix with N columns and M rows | |
Abstract base class for plugins | |
Creates plugin drivers | |
Internal helper class for marshalling arguments | |
Represents a gesture, containing properties that describe the corresponding user input | |
The description of triggered gestures | |
The infrastructure for gesture recognition | |
Used to implement a global static object | |
Direct access to the internal glyphs in a font | |
Used in combination with QBrush to specify gradient fills | |
Represents an anchor between two items in a QGraphicsAnchorLayout | |
Layout where one can anchor widgets together in Graphics View | |
Blur effect | |
Colorize effect | |
Drop shadow effect | |
The base class for all graphics effects | |
Ellipse item that you can add to a QGraphicsScene | |
Grid layout for managing widgets in Graphics View | |
The base class for all graphical items in a QGraphicsScene | |
Container that treats a group of items as a single item | |
The base class for all layouts in Graphics View | |
Can be inherited to allow your custom items to be managed by layouts | |
Line item that you can add to a QGraphicsScene | |
Horizontal or vertical layout for managing widgets in Graphics View | |
Base class for all graphics items that require signals, slots and properties | |
Opacity effect | |
Path item that you can add to a QGraphicsScene | |
Pixmap item that you can add to a QGraphicsScene | |
Polygon item that you can add to a QGraphicsScene | |
Proxy layer for embedding a QWidget in a QGraphicsScene | |
Rectangle item that you can add to a QGraphicsScene | |
Rotation transformation around a given axis | |
Scale transformation | |
Surface for managing a large number of 2D graphical items | |
Context menu events in the graphics view framework | |
Events for drag and drop in the graphics view framework | |
Base class for all graphics view related events | |
Events when a tooltip is requested | |
Hover events in the graphics view framework | |
Mouse events in the graphics view framework | |
Events for widget moving in the graphics view framework | |
Events for widget resizing in the graphics view framework | |
Wheel events in the graphics view framework | |
Simple text path item that you can add to a QGraphicsScene | |
QGraphicsItem that can be used to render the contents of SVG files | |
Text item that you can add to a QGraphicsScene to display formatted text | |
Abstract base class for building advanced transformations on QGraphicsItems | |
Widget for displaying the contents of a QGraphicsScene | |
The base class for all widget items in a QGraphicsScene | |
Implements the Gregorian calendar | |
Lays out widgets in a grid | |
Group box frame with a title | |
Manages the GUI application's control flow and main settings | |
Lines up widgets horizontally | |
Template class that provides a hash-table-based dictionary | |
Java-style const iterator for QHash and QMultiHash | |
Header row or header column for item views | |
Item for use with QHelpContentModel | |
Model that supplies content to views | |
Tree view for displaying help content model items | |
Access to contents and indices of the help engine | |
The core functionality of the help system | |
Event that is used to request helpful information about a particular point in a widget | |
Details for the filters used by QHelpFilterEngine | |
Filtered view of the help contents | |
Widget that allows for creating, editing and removing filters | |
Model that supplies index keywords to views | |
List view displaying the QHelpIndexModel | |
Struct provides the data associated with a help link | |
Access to widgets reusable to integrate fulltext search as well as to index and search documentation | |
Simple line edit or an advanced widget to enable the user to input a search term in a standardized input mask | |
The data associated with the search result | |
Text browser to display search results | |
Event which is sent after a widget is hidden | |
IP address | |
Static functions for host name lookups | |
Contains parameters that describe a mouse event | |
Specifies that a host supports HTTP Strict Transport Security policy (HSTS) | |
Controls HTTP/2 parameters and settings | |
Resembles a MIME multipart message to be sent over HTTP | |
Holds a body part to be used inside a HTTP multipart MIME message | |
The base interface class of all I/O devices in Qt | |
Scalable icons in different modes and states | |
Indicates that a main icon drag has begun | |
Abstract base class for QIcon renderers | |
Abstract base for custom QIconEngine plugins | |
Proxies its source model unmodified | |
Hardware-independent image representation that allows direct access to the pixel data, and can be used as a paint device | |
Defines the common image I/O interface for all image formats in Qt | |
Defines an interface for writing an image format plugin | |
Format independent interface for reading images from files or other devices | |
Format independent interface for writing images to files or other devices | |
Describes a device from which a QInputEvent originates | |
Simple convenience dialog to get a single value from the user | |
The base class for events that describe user input | |
Access to the active text input method | |
Parameters for input method events | |
Event sent by the input context to input objects | |
Validator that ensures a string contains a valid integer within a specified range | |
Display and editing facilities for data items from a model | |
Makes it possible to create item editor creator bases without subclassing QItemEditorCreatorBase | |
Abstract base class that must be subclassed when implementing new item editor creators | |
Widgets for editing item data in views and delegates | |
Manages information about selected items in a model | |
Keeps track of a view's selected items | |
Manages information about a range of selected items in a model | |
Template class that is the base class for QSequentialIterable and QAssociativeIterable | |
Template class that allows iteration over a container in a QVariant | |
Environment for evaluating JavaScript code | |
Acts as a container for Qt/JavaScript data types | |
Java-style iterator for QJSValue | |
Jalali (Hijri Shamsi) calendar system implementation | |
Encapsulates a JSON array | |
Way to read and write JSON documents | |
Encapsulates a JSON object | |
Used to report errors during JSON parsing | |
Encapsulates a value in JSON | |
Julian calendar system implementation | |
Stores a combination of a key with optional modifiers | |
Describes a key event | |
Encapsulates a key sequence as used by shortcuts | |
Allows to input a QKeySequence | |
Iterator over the key/value pairs of an associative container | |
Displays a number with LCD-like digits | |
Platform-independent little-endian integers | |
Text or image display | |
8-bit ASCII/Latin-1 character | |
Thin wrapper around an US-ASCII/Latin-1 encoded string literal | |
The base class of geometry managers | |
Abstract item that a QLayout manipulates | |
Loads shared libraries at runtime | |
Information about the Qt library | |
Two-dimensional vector using integer precision | |
One-line text editor | |
Two-dimensional vector using floating point precision | |
Used in combination with QBrush to specify a linear gradient brush | |
Template class that provides linked lists | |
Java-style const iterator for QLinkedList | |
Template class that provides a dynamic array | |
Java-style const iterator for QList and QQueue | |
List or icon view onto a model | |
Item-based list widget | |
Item for use with the QListWidget item view class | |
Local socket based server | |
Local socket | |
Converts between numbers and their string representations in various languages | |
Locking between processes using a file | |
Represents a category, or 'area' in the logging infrastructure | |
Main application window | |
Template class that provides an associative array | |
Java-style const iterator for QMap | |
Defines the four margins of a rectangle | |
Defines the four margins of a rectangle | |
Represents a 4x4 transformation matrix in 3D space | |
Area in which MDI windows are displayed | |
Subwindow class for QMdiArea | |
Menu widget for use in menu bars, context menus, and other popup menus | |
Horizontal menu bar | |
Way to generate hash-based message authentication codes | |
Modal dialog for informing the user or for asking the user a question and receiving an answer | |
Additional information about a log message | |
Generates log messages | |
Additional information about a class | |
Meta-data about an enumerator | |
Meta-data about a member function | |
Contains meta-information about Qt objects | |
Meta-data about a property | |
Allows type erased access to sequential containers | |
Manages named types in the meta-object system | |
Milanković calendar system implementation | |
Container for data that records information about its MIME type | |
Maintains a database of MIME types | |
Describes types of file or data, represented by a MIME type string | |
Used to locate data in a data model | |
Holds a role and the data associated to that role | |
Span over QModelRoleData objects | |
Contains parameters that describe a mouse event | |
Contains event parameters for move events | |
Convenience class for playing movies with QImageReader | |
Convenience QHash subclass that provides multi-valued hashes | |
Template class that provides an associative array with multiple equivalent keys | |
Java-style const iterator for QMultiMap. QMultiMap has both Java-style iterators and STL-style iterators. STL-style iterators are more efficient and should be preferred | |
Java-style non-const iterator for QHash and QMultiHash | |
Java-style non-const iterator for QLinkedList | |
Java-style non-const iterator for QList, QQueue and QStack | |
Java-style non-const iterator for QMap | |
Java-style non-const iterator for QMultiMap | |
Java-style non-const iterator for QSet | |
Access serialization between threads | |
Convenience class that simplifies locking and unlocking mutexes | |
Contains parameters that describe a gesture event | |
Native interface to a offscreen surface on Android | |
Native interface to an NSOpenGLContext on macOS | |
Native interface to an EGL context | |
Native interface to a GLX context | |
Provides access to and enables adopting Direct3D 11 texture objects | |
Provides access to and enables adopting Metal texture objects | |
Provides access to and enables adopting OpenGL texture objects | |
Provides access to and enables adopting Vulkan image objects | |
Native interface to a WGL context on Windows | |
Allows the application to send network requests and receive replies | |
Stores one IP address supported by a network interface, along with its associated netmask and broadcast address | |
Cache information | |
Holds one network cookie | |
Implements a simple jar of QNetworkCookie objects | |
The data and metadata of a UDP datagram | |
Very basic disk cache | |
Listing of the host's IP addresses and network interfaces | |
Network layer proxy | |
Fine-grained proxy selection | |
Used to query the proxy settings for a socket | |
Contains the data and headers for a request sent with QNetworkAccessManager | |
Holds a request to be sent with QNetworkAccessManager | |
Implementation of the OAuth 1 Protocol | |
Implements OAuth 1 signature methods | |
Implementation of the Authorization Code Grant flow | |
The base class of all Qt objects | |
Template class that enables automatic property bindings for property data stored in QObject derived classes | |
Watches the lifetime of multiple QObjects | |
This class represents Online Certificate Status Protocol response | |
Represents an offscreen surface in the underlying platform | |
Functions for creating and managing OpenGL buffer objects | |
Represents a native OpenGL context, enabling OpenGL rendering on a QSurface | |
Represents a group of contexts sharing OpenGL resources | |
Enables logging of OpenGL debugging messages | |
Wraps an OpenGL debug message | |
Cross-platform access to the OpenGL ES 3.0, 3.1 and 3.2 API | |
Encapsulates an OpenGL framebuffer object | |
Specifies the format of an OpenGL framebuffer object | |
Cross-platform access to the OpenGL ES 2.0 API | |
All functions for OpenGL 1.0 specification | |
All functions for OpenGL 1.1 specification | |
All functions for OpenGL 1.2 specification | |
All functions for OpenGL 1.3 specification | |
All functions for OpenGL 1.4 specification | |
All functions for OpenGL 1.5 specification | |
All functions for OpenGL 2.0 specification | |
All functions for OpenGL 2.1 specification | |
All functions for OpenGL 3.0 specification | |
All functions for OpenGL 3.1 specification | |
All functions for OpenGL 3.2 compatibility profile | |
All functions for OpenGL 3.2 core profile | |
All functions for OpenGL 3.3 compatibility profile | |
All functions for OpenGL 3.3 core profile | |
All functions for OpenGL 4.0 compatibility profile | |
All functions for OpenGL 4.0 core profile | |
All functions for OpenGL 4.1 compatibility profile | |
All functions for OpenGL 4.1 core profile | |
All functions for OpenGL 4.2 compatibility profile | |
All functions for OpenGL 4.2 core profile | |
All functions for OpenGL 4.3 compatibility profile | |
All functions for OpenGL 4.3 core profile | |
All functions for OpenGL 4.4 compatibility profile | |
All functions for OpenGL 4.4 core profile | |
All functions for OpenGL 4.5 compatibility profile | |
All functions for OpenGL 4.5 core profile | |
All functions for OpenGL ES 2 | |
Enables painting to an OpenGL context using QPainter | |
Describes the pixel storage modes that affect the unpacking of pixels during texture upload | |
Allows OpenGL shaders to be compiled | |
Allows OpenGL shader programs to be linked and used | |
Encapsulates an OpenGL texture object | |
Convenient way to draw textured quads via OpenGL | |
Wraps a sequence of OpenGL timer query objects | |
Wraps an OpenGL timer query object | |
Provides access to OpenGL functions for a specified version and profile | |
Represents the version and if applicable the profile of an OpenGL context | |
Wraps an OpenGL Vertex Array Object | |
Widget for rendering OpenGL graphics | |
Convenience subclass of QWindow to perform OpenGL painting | |
Information about the operating system version | |
Describes the size, orientation and margins of a page | |
Represents a collection of page ranges | |
Configuration dialog for the page-related options on a printer | |
Describes the size and name of a defined page size | |
Represents a paint device that supports multiple pages | |
The base class of objects that can be painted on with QPainter | |
Convenience subclass of QWindow that is also a QPaintDevice | |
Abstract definition of how QPainter draws to a given device on a given platform | |
Information about the active paint engine's current state | |
Contains event parameters for paint events | |
Performs low-level painting on widgets and other paint devices | |
Container for painting operations, enabling graphical shapes to be constructed and reused | |
Used to generate fillable outlines for a given painter path | |
Contains color groups for each widget state | |
Describes a panning gesture made by the user | |
Parallel group of animations | |
Represents the result of a comparison that allows for unordered results | |
Pause for QSequentialAnimationGroup | |
Class to generate PDFs that can be used as a paint device | |
Defines how a QPainter should draw lines and outlines of shapes | |
Used to locate data in a data model | |
Paint device that records and replays QPainter commands | |
Describes a pinch gesture made by the user | |
Class for describing different pixel layouts in graphics buffers | |
Off-screen image representation that can be used as a paint device | |
Application-wide cache for pixmaps | |
Implements a plain text layout for QTextDocument | |
Widget that is used to edit and display plain text | |
Used to notify about native platform surface events | |
Loads a plugin at run-time | |
Defines a point in the plane using integer precision | |
Defines a point in the plane using floating point precision | |
Template class that provides guarded pointers to QObject | |
A base class for pointer events | |
Describes a device from which mouse, touch or tablet events originate | |
Identifies a unique object, such as a tagged token or stylus, which is used with a pointing device | |
List of points using integer precision | |
List of points using floating point precision | |
Dialog for specifying the printer's configuration | |
Defines an interface for how QPrinter interacts with a given printing subsystem | |
Dialog for previewing and configuring page layouts for printer output | |
Widget for previewing page layouts for printer output | |
Paint device that paints on a printer | |
Gives access to information about existing printers | |
Used to start external programs and to communicate with them | |
Holds the environment variables that can be passed to a program | |
Horizontal or vertical progress bar | |
Feedback on the progress of a slow operation | |
Way to store computation results to be accessed by QFuture | |
Template class that enables automatic property bindings | |
Safe alias for a QProperty with same template parameter | |
Animates Qt properties | |
Controls the lifecycle of change callback installed on a QProperty | |
Helper class for properties with automatic property bindings | |
Convenience class that simplifies dynamically overriding QStyle elements | |
Command button | |
Allows you to control QML file loading | |
Convenient way to load an application from a single QML file | |
Encapsulates a QML component definition | |
Defines a context within a QML engine | |
Environment for instantiating QML components | |
Abstract base for custom QML extension plugins | |
Encapsulates a QML error | |
Evaluates JavaScript in a QML context | |
A class for applying a QFileSelector to QML file loading | |
Used to register image providers in the QML engine | |
Instances drive the progress of QQmlIncubators | |
Allows QML objects to be created asynchronously | |
Allows applications to expose list-like properties of QObject-derived classes to QML | |
Allows the manipulation of QQmlListProperty properties | |
Creates QNetworkAccessManager instances for a QML engine | |
Updates on the QML parser state | |
Abstracts accessing properties on objects created from QML | |
Allows you to set key-value pairs that can be used in QML bindings | |
Interface for property value sources such as animations and bindings | |
Encapsulates a script and its context | |
Represents a quaternion consisting of a vector and scalar | |
Generic container that provides a queue | |
Helper class for selecting correct surface format | |
Base class for defining custom geometry | |
Base class of all 3D nodes and resources | |
Base class for defining custom texture data | |
Interface for for asynchronous control of QML image requests | |
Represents a set of colors | |
Convenience class for integrating OpenGL rendering using a framebuffer object (FBO) with Qt Quick | |
Container for low-level graphics settings that can affect how the underlying graphics API, such as Vulkan, is initialized by the Qt Quick scene graph. It can also control certain aspects of the scene graph renderer | |
Opaque container for native graphics objects representing graphics devices or contexts | |
Interface for supporting pixmaps and threaded image requests in QML | |
Interface for asynchronous image loading in QQuickAsyncImageProvider | |
The most basic of all visual items in Qt Quick | |
Contains the result from QQuickItem::grabToImage() | |
Way to use the QPainter API in the QML Scene Graph | |
Mechanism for rendering the Qt Quick scenegraph onto an offscreen render target in a fully application-controlled manner | |
Opaque container for native graphics resources specifying a render target, and associated metadata | |
Allows configuring the application style | |
Access to the QTextDocument of QQuickTextEdit | |
Interface for loading custom textures from QML | |
Window for displaying a Qt Quick user interface | |
Widget for displaying a Qt Quick user interface | |
The window for displaying a graphical QML scene | |
Used in combination with QBrush to specify a radial gradient brush | |
Radio button with a text label | |
Allows one to obtain random values from a high-quality Random Number Generator | |
Allows one to obtain 64-bit random values from a high-quality, seed-less Random Number Generator | |
Enables hardware acceleration of painting operations in Qt for Embedded Linux | |
Convenience class for using QPainter on a QWindow | |
Access to a single physical instance of a font | |
Convenience class that simplifies locking and unlocking read-write locks for read access | |
Read-write locking | |
Defines a rectangle in the plane using integer precision | |
Defines a rectangle in the plane using floating point precision | |
Access serialization between threads | |
Pattern matching using regular expressions | |
Specifies a clip region for a painter | |
Pattern matching using regular expressions | |
The results of a matching a QRegularExpression against a string | |
Iterator on the results of a global match of a QRegularExpression object against a string | |
Used to check a string against a regular expression | |
Contains event parameters for resize events | |
Interface for reading directly from resources | |
Struct contains a 64-bit RGB color | |
Shared base for calendars based on the ancient Roman calendar | |
Rectangle or line that can indicate a selection or a boundary | |
The base class for all runnable objects | |
Serves as a baseclass for geometry based nodes | |
Implements the clipping functionality in the scene graph | |
Serves as a baseclass for dynamically changing textures, such as content that is rendered to FBO's | |
Convenient way of rendering solid colored geometry in the scene graph | |
Low-level storage for graphics primitives in the Qt Quick Scene Graph | |
Used for all rendered content in the scene graph | |
Provided for convenience to easily draw textured content using the QML scene graph | |
Encapsulates rendering state for a shader program | |
Represents a graphics API independent shader program | |
Used as a unique type token in combination with QSGMaterial | |
The base class for all nodes in the scene graph | |
Used to change opacity of nodes | |
Convenient way of rendering textured geometry in the scene graph | |
Convenience class for drawing solid filled rectangles using scenegraph | |
Represents a set of custom rendering commands targeting the graphics API that is in use by the scenegraph | |
An interface providing access to some of the graphics API specific internals of the scenegraph | |
Convenience class for drawing solid filled rectangles using scenegraph | |
Provided for convenience to easily draw textured content using the QML scene graph | |
The base class for textures used in the scene graph | |
Convenient way of rendering textured geometry in the scene graph | |
Encapsulates texture based entities in QML | |
Implements transformations in the scene graph | |
Convenient way of rendering per-vertex colored geometry in the scene graph | |
Interface for safely writing to files | |
Provides a scope guard for calling a function at the end of a scope | |
Stores a pointer to a dynamically allocated array of objects, and deletes it upon destruction | |
Stores a pointer to a dynamically allocated object, and deletes it upon destruction | |
Resets a variable to its previous value on destruction | |
Used to query screen properties | |
Scrolling view onto another widget | |
Vertical or horizontal scroll bar | |
Sent when scrolling | |
Sent in preparation of scrolling | |
Enables kinetic scrolling for any scrolling widget or graphics item | |
Stores the settings for a QScroller | |
SCTP-based server | |
SCTP socket | |
General counting semaphore | |
Exception-safe deferral of a QSemaphore::release() call | |
Sequential group of animations | |
Iterable interface for a container in a QVariant | |
Access to the session manager | |
Template class that provides a hash-table-based set | |
Java-style const iterator for QSet | |
Persistent platform-independent application settings | |
Base class for shared data objects | |
Represents a pointer to an implicitly shared object | |
Access to a shared memory segment | |
Holds a strong reference to a shared pointer | |
Used to create keyboard shortcuts | |
Event which is generated when the user presses a key combination | |
Event that is sent when a widget is shown | |
Exception-safe wrapper around QObject::blockSignals() | |
Bundles signals from identifiable senders | |
Enables introspection of signal emission | |
A base class for pointer events containing a single point, such as mouse events | |
Defines the size of a two-dimensional object using integer point precision | |
Defines the size of a two-dimensional object using floating point precision | |
Resize handle for resizing top-level windows | |
Layout attribute describing horizontal and vertical resizing policy | |
Vertical or horizontal slider | |
Support for monitoring activity on a file descriptor | |
Support for sorting and filtering data passed between another model and a view | |
Blank space in a layout | |
Spin box widget | |
Splash screen that can be shown during application startup | |
Implements a splitter widget | |
Handle functionality for the splitter | |
Handles a connection to a database | |
Abstract base class for accessing specific SQL databases | |
Template class that provides a SQL driver factory for a specific driver type | |
The base class for SQL driver factories | |
Abstract base for custom QSqlDriver plugins | |
SQL database error information | |
Manipulates the fields in SQL database tables and views | |
Functions to manipulate and describe database indexes | |
Means of executing and manipulating SQL statements | |
Read-only data model for SQL result sets | |
Encapsulates a database record | |
Stores information about an SQL foreign key | |
Delegate that is used to display and edit data from a QSqlRelationalTableModel | |
Editable data model for a single database table, with foreign key support | |
Abstract interface for accessing data from specific SQL databases | |
Editable data model for a single database table | |
Convenient API for an X509 certificate | |
API for accessing the extensions of an X509 certificate | |
Represents an SSL cryptographic cipher | |
Holds the configuration and state of an SSL connection | |
Interface for Diffie-Hellman parameters for servers | |
Represents an elliptic curve for use by elliptic-curve cipher algorithms | |
SSL error | |
Interface for private and public keys | |
Authentication data for pre shared keys (PSK) ciphersuites | |
SSL encrypted socket for both clients and servers | |
Template class that provides a stack | |
Stack of widgets where only one widget is visible at a time | |
Stack of widgets where only one widget is visible at a time | |
Item for use with the QStandardItemModel class | |
The possibility to register widgets without having to subclass QItemEditorCreatorBase | |
Generic model for storing custom data | |
Methods for accessing standard paths | |
Compile-time version of QByteArrayMatcher | |
Struct containing a reference to a static plugin instance together with its meta data | |
Enables optimized drawing of text when the text and its layout is updated rarely | |
Horizontal bar suitable for presenting status information | |
Event that is used to show messages in a status bar | |
Provides information about currently mounted storage and drives | |
Unicode character string | |
Base class for encoding and decoding text | |
State-based decoder for text | |
State-based encoder for text | |
List of strings | |
Model that supplies strings to views | |
Holds a sequence of characters that can be quickly matched in a Unicode string | |
Thin wrapper around QString substrings | |
Splits strings into tokens along given separators | |
Unified view on UTF-16 strings with a read-only subset of the QString API | |
Abstract base class that encapsulates the look and feel of a GUI | |
Creates QStyle objects | |
Style hints that return more than basic data types | |
Style hints that return a QRegion | |
Style hints that return a QVariant | |
Contains platform specific hints and settings | |
Stores the parameters used by QStyle functions | |
Used to describe the parameters for drawing buttons | |
Used to describe the parameter for drawing a combobox | |
Used to hold parameters that are common to all complex controls | |
Used to describe the parameters for drawing a dock widget | |
Used to describe the parameters for drawing a focus rectangle with QStyle | |
Used to describe the parameters for drawing a frame | |
Used to describe the parameters needed to draw a QGraphicsItem | |
Describes the parameters for drawing a group box | |
Used to describe the parameters for drawing a header | |
Used to describe the parameter necessary for drawing a menu item | |
Used to describe the parameters necessary for drawing a progress bar | |
Used to describe the parameters needed for drawing a rubber band | |
Used to describe the parameter for drawing a size grip | |
Used to describe the parameters needed for drawing a slider | |
Used to describe the parameters necessary for drawing a spin box | |
Used to describe the parameters for drawing a tab bar | |
Used to describe the base of a tab bar, i.e. the part that the tab bar usually overlaps with | |
Used to describe the parameters for drawing the frame around a tab widget | |
Used to describe the parameters for drawing a title bar | |
Used to describe the parameters for drawing a toolbar | |
Used to describe the parameters needed for drawing a tool box | |
Used to describe the parameters for drawing a tool button | |
Used to describe the parameters used to draw an item in a view widget | |
Convenience class for drawing QStyle elements inside a widget | |
Abstract base for custom QStyle plugins | |
Display and editing facilities for data items from a model | |
Used when registering fonts with the internal Qt fontdatabase | |
Abstraction of renderable surfaces in Qt | |
Represents the format of a QSurface | |
Paint device that is used to create SVG drawings | |
Used to draw the contents of SVG files onto paint devices | |
Widget that is used to display the contents of Scalable Vector Graphics (SVG) files | |
Describes a swipe gesture made by the user | |
Allows you to define syntax highlighting rules, and in addition you can use the class to query a document's current formatting or user data | |
Information about the system | |
General counting system semaphore | |
Icon for an application in the system tray | |
Tab bar, e.g. for use in tabbed dialogs | |
Stack of tabbed widgets | |
Default model/view implementation of a table view | |
Item-based table view with a default model | |
Item for use with the QTableWidget class | |
Way to interact with selection in a model without using model indexes and a selection model | |
Contains parameters that describe a Tablet event | |
Template class that wraps an iterator and exposes standard iterator traits | |
Describes a tap-and-hold (aka LongTap) gesture made by the user | |
Describes a tap gesture made by the user | |
TCP-based server | |
TCP socket | |
Creates a unique directory for temporary use | |
I/O device that operates on temporary files | |
Used to simulate a sequence of touch events | |
List of GUI events | |
Container for text fragments in a QTextDocument | |
Formatting information for blocks of text in a QTextDocument | |
Container for text blocks within a QTextDocument | |
Used to associate custom data with blocks of text | |
Way of finding Unicode text boundaries in a string | |
Rich text browser with hypertext navigation | |
Formatting information for characters in a QTextDocument | |
Conversions between text encodings | |
Offers an API to access and modify QTextDocuments | |
State-based decoder | |
Holds formatted text | |
Represents a piece of formatted text from a QTextDocument | |
Format-independent interface for writing a QTextDocument to files or other devices | |
Widget that is used to edit and display both plain and rich text | |
State-based encoder | |
Formatting information for a QTextDocument | |
Holds a piece of text in a QTextDocument with a single QTextCharFormat | |
Represents a frame in a QTextDocument | |
Formatting information for frames in a QTextDocument | |
Formatting information for images in a QTextDocument | |
Represents an inline object in a QAbstractTextDocumentLayout and its implementations | |
All the information required to draw text in a custom paint engine | |
Used to lay out and render text | |
Encapsulates the different types of length used in a QTextDocument | |
Represents a line of text inside a QTextLayout | |
Decorated list of items in a QTextDocument | |
Formatting information for lists in a QTextDocument | |
Base class for different kinds of objects that can group parts of a QTextDocument together | |
Allows drawing of custom text objects in QTextDocuments | |
Description of general rich text properties | |
Convenient interface for reading and writing text | |
Represents a table in a QTextDocument | |
Represents the properties of a cell in a QTextTable | |
Formatting information for table cells in a QTextDocument | |
Formatting information for tables in a QTextDocument | |
Platform-independent way to manage threads | |
Manages a collection of QThreads | |
Per-thread data storage | |
The rules used to draw a pixmap or image split into nine segments | |
Clock time functions | |
Widget for editing times based on the QDateTimeEdit widget | |
Timeline for controlling animations | |
Converts between UTC and local time in a specific time zone | |
Repetitive and single-shot timers | |
Contains parameters that describe a timer event | |
Movable panel that contains a set of controls | |
Column of tabbed widget items | |
Quick-access button to commands or options, usually used inside a QToolBar | |
Tool tips (balloon help) for any widget | |
Contains parameters that describe a touch event | |
Specifies 2D transformations of a coordinate system | |
Internationalization support for text output | |
This proxy transposes the source model | |
Default model/view implementation of a tree view | |
Tree view that uses a predefined tree model | |
Item for use with the QTreeWidget convenience class | |
Way to iterate over the items in a QTreeWidget instance | |
Contains a lightweight representation of a version number with two 8-bit segments, major and minor, either of which can be unknown | |
UDP socket | |
Enables standalone applications to dynamically create user interfaces at run-time using the information stored in UI files or specified in plugin paths | |
The base class of all commands stored on a QUndoStack | |
Group of QUndoStack objects | |
Stack of QUndoCommand objects | |
Displays the contents of a QUndoStack | |
Represents an unhandled exception in a Qt Concurrent worker thread | |
Convenient interface for working with URLs | |
Way to manipulate a key-value pairs in a URL's query | |
Unified view on UTF-8 strings with a read-only subset of the QString API | |
Stores a Universally Unique Identifier (UUID) | |
Lines up widgets vertically | |
Validation of input text | |
Low-level variable-length array | |
Acts like a union for the most common Qt data types | |
Base class for animations | |
Emulated const pointer to QVariant based on a pointer | |
Template class that emulates a pointer to QVariant based on a pointer | |
Acts as a non-const reference to a QVariant | |
Alias for QList | |
Represents a vector or vertex in 2D space | |
Represents a vector or vertex in 3D space | |
Represents a vector or vertex in 4D space | |
Contains a version number with an arbitrary number of segments | |
Cross-platform access to the device level core Vulkan 1.0 API | |
Represents information about a Vulkan extension | |
Cross-platform access to the instance level core Vulkan 1.0 API | |
A specialized QList for QVulkanLayer and QVulkanExtension | |
Represents a native Vulkan instance, enabling Vulkan rendering onto a QSurface | |
Represents information about a Vulkan layer | |
Convenience subclass of QWindow to perform Vulkan rendering | |
Used to implement the application-specific rendering logic for a QVulkanWindow | |
Condition variable for synchronizing threads | |
Holds the reference to a surface buffer | |
Represents a client connecting to the QWaylandCompositor | |
Manages the Wayland display server | |
Provides an extension that allows to inhibit the idle behavior of the compositor | |
Extension for embedded-style user interfaces | |
Simple way to identify and resize a surface | |
Represents a keyboard device | |
Represents a displayable area managed by the compositor | |
Holds the resolution and refresh rate of an output | |
Represents a pointer device | |
Provides access to input methods in the compositor | |
Qt Quick item representing a QWaylandView | |
Provides support for shell surface integration with QtQuick | |
Qt Quick item that represents a QWaylandShellSurface | |
Access to keyboard, mouse, and touch input | |
Common interface for surface roles specified by shell extensions | |
Represents a rectangular area on an output device | |
Allows to read the content of a QWaylandSurface | |
Access to a touch device | |
Represents a view of a surface on an output | |
Provides an extension for surface resizing and cropping | |
Extension for desktop-style user interfaces | |
Desktop-style compositor-specific features to a surface | |
Provides an extension for negotiation of server-side and client-side window decorations | |
Provides an extension for describing outputs in a desktop oriented fashion | |
Represents the popup specific parts of an xdg surface | |
Extension for desktop-style user interfaces | |
Desktop-style compositor-specific features to an xdg surface | |
Represents the toplevel window specific parts of an xdg surface | |
Holds a weak reference to a shared pointer | |
Simple description of any widget, i.e. answering the question "What's This?" | |
Event that can be used to handle hyperlinks in a "What's This?" text | |
Contains parameters that describe a wheel event | |
The base class of all user interface objects | |
Extends QAction by an interface for inserting custom widgets into action based containers, such as toolbars | |
Layout item that represents a widget | |
Support for the Windows Wait functions | |
Represents a window in the underlying windowing system | |
The window state before a window state change | |
Framework for wizards | |
The base class for wizard pages | |
Convenience class that simplifies locking and unlocking read-write locks for write access | |
XML attributes | |
Interface to report the logical content of XML data | |
Interface to report DTD content of XML data | |
Interface to report declaration content of XML data | |
Default implementation of all the XML handler classes | |
Interface to resolve external entities contained in XML data | |
Interface to report errors in XML data | |
The input data for the QXmlReader subclasses | |
Interface to report the lexical content of XML data | |
The XML handler classes with information about the parsing position within a file | |
Helper class for XML readers which want to include namespace support | |
Used to report errors with the QXmlErrorHandler interface | |
Interface for XML readers (i.e. parsers) | |
Implementation of a simple XML parser | |
Represents a single XML attribute | |
Represents a vector of QXmlStreamAttribute | |
Represents a DTD entity declaration | |
Entity resolver for a QXmlStreamReader | |
Represents a namespace declaration | |
Represents a DTD notation declaration | |
Fast parser for reading well-formed XML via a simple streaming API | |
XML writer with a simple streaming API | |
The base class for aspects that provide a vertical slice of behavior | |
Abstract base class for all functors | |
A skeleton contains the joints for a skinned mesh | |
Used to calculate skinning transform matrices and set them on shaders | |
Responsible for handling all the QAbstractAspect subclasses that have been registered with the scene | |
Base class for jobs executed in an aspect | |
Defines an attribute and how data should be read from a QBuffer | |
Base class for all Qt3D backend nodes | |
Creates and maps backend nodes to their respective frontend nodes | |
Can be used to override the bounding volume of an entity | |
Provides a data store for raw data to later be used as vertices or uniforms | |
Base class of scene nodes that can be aggregated by Qt3DCore::QEntity instances as a component | |
Holds settings related to core data handling process | |
Qt3DCore::QEntity is a Qt3DCore::QNode subclass that can aggregate several Qt3DCore::QComponent instances that will specify its behavior | |
Encapsulates geometry | |
Encapsulates geometry details | |
Used to transforms parts of skinned meshes | |
The base class of all Qt3D node classes used to build a Qt3D scene | |
Uniquely identifies a QNode | |
Holds the data for a skeleton to be used with skinned meshes | |
Used to load a skeleton of joints from file | |
Used to perform transforms on meshes | |
Qt3DInput::QAbstractPhysicalDeviceProxy acts as a proxy for an actual Qt3DInput::QQAbstractPhysicalDevice device | |
Abstract base class used to define new input methods such as game controllers | |
Used for adjusting task parameters | |
Provides 16-bit floating point support |
© 2020 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.