Qt classes with brief descriptions:
Used to notify when a node is created |
|
Abstract class that provides an API to initialize and access a COM object |
|
Wrapper around script code |
|
Wrapper around a script engine |
|
Bridge between application objects and script code |
|
Selection dialog for registered COM components |
|
QWidget that wraps an ActiveX control |
|
Abstract base class for implementations of additional COM interfaces |
|
Interface between a QWidget and an ActiveX client |
|
Defines a factory for the creation of COM components |
|
The base of all animations |
|
Abstract base class for groups of animations |
|
Parallel group of animations |
|
Pause for QSequentialAnimationGroup |
|
Animates Qt properties |
|
Sequential group of animations |
|
Base class for animations |
|
Conversions between text encodings |
|
State-based decoder |
|
State-based encoder |
|
Platform-independent big-endian integers |
|
Platform-independent little-endian integers |
|
Additional information about a log message |
|
Generates log messages |
|
QIODevice interface for a QByteArray |
|
Output stream for debugging information |
|
Convenience class for custom QDebug operators |
|
Access to directory structures and their contents |
|
Iterator for directory entrylists |
|
Interface for reading from and writing to files |
|
Interface for reading from and writing to open files |
|
System-independent file information |
|
Convenient way of selecting file variants |
|
Interface for monitoring files and directories for modifications |
|
The base interface class of all I/O devices in Qt |
|
Locking between processes using a file |
|
Represents a category, or 'area' in the logging infrastructure |
|
Used to start external programs and to communicate with them |
|
Holds the environment variables that can be passed to a program |
|
Interface for reading directly from resources |
|
Interface for safely writing to files |
|
Persistent platform-independent application settings |
|
Methods for accessing standard paths |
|
Provides information about currently mounted storage and drives |
|
Creates a unique directory for temporary use |
|
I/O device that operates on temporary files |
|
Convenient interface for working with URLs |
|
Way to manipulate a key-value pairs in a URL's query |
|
The abstract interface for item model classes |
|
Abstract model that can be subclassed to create one-dimensional list models |
|
Abstract model that can be subclassed to create table models |
|
Used to locate data in a data model |
|
Used to locate data in a data model |
|
Base class for proxy item models that can do sorting, filtering or other data processing tasks |
|
Proxies its source model unmodified |
|
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 |
|
Support for sorting and filtering data passed between another model and a view |
|
Model that supplies strings to views |
|
Interface to manage Qt's event queue |
|
Interface for receiving native events, such as MSG or XCB event structs |
|
Timer events for objects |
|
Event loop for Qt applications without UI |
|
Contains event parameters for child object events |
|
Contains event parameters for dynamic property change events |
|
The base class of all event classes. Event objects contain event parameters |
|
Contains parameters that describe a timer event |
|
Marks a deadline in the future |
|
Fast way to calculate elapsed times |
|
Means of entering and leaving an event loop |
|
Means to quit an event loop when it is no longer needed |
|
Additional information about a class |
|
Meta-data about an enumerator |
|
Meta-data about a member function |
|
Meta-data about a property |
|
Manages named types in the meta-object system |
|
Container for data that records information about its MIME type |
|
The base class of all Qt objects |
|
Exception-safe wrapper around QObject::blockSignals() |
|
Watches the lifetime of multiple QObjects |
|
Internal helper class for marshalling arguments |
|
Internal helper class for marshalling arguments |
|
Contains meta-information about Qt objects |
|
Template class that provides guarded pointers to QObject |
|
Access to a shared memory segment |
|
Support for monitoring activity on a file descriptor |
|
General counting system semaphore |
|
Repetitive and single-shot timers |
|
Internationalization support for text output |
|
Iterable interface for an associative container in a QVariant |
|
Iterable interface for a container in a QVariant |
|
Acts like a union for the most common Qt data types |
|
Support for the Windows Wait functions |
|
Maintains a database of MIME types |
|
Describes types of file or data, represented by a MIME type string |
|
Loads shared libraries at runtime |
|
Struct containing a reference to a static plugin instance together with its meta data |
|
Loads a plugin at run-time |
|
Stores a Universally Unique Identifier (UUID) |
|
Serialization of binary data to a QIODevice |
|
Encapsulates a JSON array |
|
Way to read and write JSON documents |
|
Used to report errors during JSON parsing |
|
Encapsulates a JSON object |
|
Encapsulates a value in JSON |
|
Convenient interface for reading and writing text |
|
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 of states of a QStateMachine |
|
The base class of transitions between QAbstractState objects |
|
QObject-specific transition for Qt events |
|
Final state |
|
Means of returning to a previously active substate |
|
Transition based on a Qt signal |
|
General-purpose state for QStateMachine |
|
Hierarchical finite state machine |
|
Platform-independent atomic operations on int |
|
Platform-independent atomic operations on integers |
|
Template class that provides platform-independent atomic operations on pointers |
|
Base class for exceptions that can transferred across threads |
|
UnhandledException class represents an unhandled exception in a worker thread |
|
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 |
|
Access serialization between threads |
|
Convenience class that simplifies locking and unlocking mutexes |
|
Convenience class that simplifies locking and unlocking read-write locks for read access |
|
Read-write locking |
|
Convenience class that simplifies locking and unlocking read-write locks for write access |
|
The base class for all runnable objects |
|
General counting semaphore |
|
Exception-safe deferral of a QSemaphore::release() call |
|
Platform-independent way to manage threads |
|
Manages a collection of QThreads |
|
Per-thread data storage |
|
Condition variable for synchronizing threads |
|
Array of bits |
|
Array of bytes |
|
List of byte arrays |
|
Holds a sequence of bytes that can be quickly matched in a byte array |
|
Compile-time version of QByteArrayMatcher |
|
Template class that provides a cache |
|
16-bit Unicode character |
|
8-bit ASCII/Latin-1 character |
|
Compares strings according to a localized collation algorithm |
|
Can be used to speed up string collation |
|
Defines a possible command-line option |
|
Means for handling the command line options |
|
Template class that provides a contiguous cache |
|
Way to generate cryptographic hashes |
|
Date functions |
|
Date and time functions |
|
Clock time functions |
|
Easing curves for controlling animation |
|
Template class that provides a hash-table-based dictionary |
|
Java-style const iterator for QHash and QMultiHash |
|
Convenience QHash subclass that provides multi-valued hashes |
|
Java-style non-const iterator for QHash and QMultiHash |
|
Iterator over the key/value pairs of an associative container |
|
Two-dimensional vector using integer precision |
|
Two-dimensional vector using floating point precision |
|
Template class that provides linked lists |
|
Java-style const iterator for QLinkedList |
|
Java-style non-const iterator for QLinkedList |
|
Template class that provides lists |
|
Java-style const iterator for QList and QQueue |
|
Java-style non-const iterator for QList and QQueue |
|
Converts between numbers and their string representations in various languages |
|
Template class that provides a red-black-tree-based dictionary |
|
Java-style const iterator for QMap and QMultiMap |
|
Convenience QMap subclass that provides multi-valued maps |
|
Java-style non-const iterator for QMap and QMultiMap |
|
Defines the four margins of a rectangle |
|
Defines the four margins of a rectangle |
|
Way to generate hash-based message authentication codes |
|
Template class that stores a pair of items |
|
Defines a point in the plane using integer precision |
|
Defines a point in the plane using floating point precision |
|
Generic container that provides a queue |
|
Defines a rectangle in the plane using integer precision |
|
Defines a rectangle in the plane using floating point precision |
|
Pattern matching using regular expressions |
|
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 |
|
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 |
|
Java-style non-const iterator for QSet |
|
Template class that provides a hash-table-based set |
|
Java-style const iterator for QSet |
|
Represents a pointer to an explicitly shared object |
|
Base class for shared data objects |
|
Represents a pointer to an implicitly shared object |
|
A base class that allows obtaining a QSharedPointer for an object already managed by a shared pointer |
|
Holds a strong reference to a shared pointer |
|
Holds a weak reference to a shared pointer |
|
Defines the size of a two-dimensional object using integer point precision |
|
Defines the size of a two-dimensional object using floating point precision |
|
Template class that provides a stack |
|
Thin wrapper around an US-ASCII/Latin-1 encoded string literal |
|
Unicode character string |
|
Thin wrapper around QString substrings |
|
List of strings |
|
Holds a sequence of characters that can be quickly matched in a Unicode string |
|
Unified view on UTF-16 strings with a read-only subset of the QString API |
|
Way of finding Unicode text boundaries in a string |
|
Timeline for controlling animations |
|
Converts between UTC and local time in a specific time zone |
|
Low-level variable-length array |
|
Java-style non-const iterator for QVector and QStack |
|
Template class that provides a dynamic array |
|
Java-style const iterator for QVector and QStack |
|
Contains a version number with an arbitrary number of segments |
|
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 |
|
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 |
|
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 parts of the QAccessibleInterface for QObjects |
|
Abstract base class for plugins provinding accessibility information for user interface elements |
|
Monochrome (1-bit depth) pixmaps |
|
Scalable icons in different modes and states |
|
Abstract base class for QIcon renderers |
|
Abstract base for custom QIconEngine plugins |
|
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 |
|
Convenience class for playing movies with QImageReader |
|
Paint device that records and replays QPainter commands |
|
Off-screen image representation that can be used as a paint device |
|
Application-wide cache for pixmaps |
|
Item for use with the QStandardItemModel class |
|
Generic model for storing custom data |
|
Access to the window system clipboard |
|
Mouse cursor with an arbitrary shape |
|
Support for MIME-based drag and drop data transfer |
|
Event that is generated when a QAction is added, removed, or changed |
|
Contains parameters that describe a close event |
|
Contains parameters that describe a context menu event |
|
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 |
|
Contains parameters that describe an enter event |
|
Contains event parameters for expose events |
|
Event that will be sent when there is a request to open a file or a URL |
|
Contains event parameters for widget focus events |
|
Event that is used to request helpful information about a particular point in a widget |
|
Event which is sent after a widget is hidden |
|
Contains parameters that describe a mouse event |
|
Indicates that a main icon drag has begun |
|
The base class for events that describe user input |
|
Parameters for input method events |
|
Event sent by the input context to input objects |
|
Describes a key event |
|
Contains parameters that describe a mouse event |
|
Contains event parameters for move events |
|
Contains parameters that describe a gesture event |
|
Contains event parameters for paint events |
|
Used to notify about native platform surface events |
|
Identifies a unique object, such as a tagged token or stylus, which is used with a pointing device |
|
Contains event parameters for resize events |
|
Sent when scrolling |
|
Sent in preparation of scrolling |
|
Event which is generated when the user presses a key combination |
|
Event that is sent when a widget is shown |
|
Event that is used to show messages in a status bar |
|
Contains parameters that describe a Tablet event |
|
Contains parameters that describe a touch event |
|
Event that can be used to handle hyperlinks in a "What's This?" text |
|
Contains parameters that describe a wheel event |
|
The window state before a window state change |
|
Abstract base class for plugins |
|
Creates plugin drivers |
|
Manages the GUI application's control flow and main settings |
|
Access to the active text input method |
|
Encapsulates a key sequence as used by shortcuts |
|
Represents an offscreen surface in the underlying platform |
|
Represents a native OpenGL context, enabling OpenGL rendering on a QSurface |
|
Represents a group of contexts sharing OpenGL resources |
|
Represents the version and if applicable the profile of an OpenGL context |
|
Convenience subclass of QWindow to perform OpenGL painting |
|
Convenience subclass of QWindow that is also a QPaintDevice |
|
Contains color groups for each widget state |
|
Class for describing different pixel layouts in graphics buffers |
|
Convenience class for using QPainter on a QWindow |
|
Used to query screen properties |
|
Access to the session manager |
|
Contains platform specific hints and settings |
|
Abstraction of renderable surfaces in Qt |
|
Represents the format of a QSurface |
|
Describes the device from which touch events originate |
|
Represents a window in the underlying windowing system |
|
Template class that represents a NxM transformation matrix with N columns and M rows |
|
Represents a 4x4 transformation matrix in 3D space |
|
Represents a quaternion consisting of a vector and scalar |
|
Represents a vector or vertex in 2D space |
|
Represents a vector or vertex in 3D space |
|
Represents a vector or vertex in 4D space |
|
Functions for creating and managing OpenGL buffer objects |
|
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 3.2 core profile |
|
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 |
|
The base class of a family of classes that expose all functions for each OpenGL version and profile |
|
Wraps an OpenGL Vertex Array Object |
|
Drawing area for QWindow |
|
Defines the fill pattern of shapes drawn by QPainter |
|
Used in combination with QBrush to specify a conical gradient brush |
|
Used in combination with QBrush to specify gradient fills |
|
Used in combination with QBrush to specify a linear gradient brush |
|
Used in combination with QBrush to specify a radial gradient brush |
|
Colors based on RGB, HSV or CMYK values |
|
Represents a paintdevice that supports multiple pages |
|
Describes the size, orientation and margins of a page |
|
Describes the size and name of a defined page size |
|
The base class of objects that can be painted on with QPainter |
|
Abstract definition of how QPainter draws to a given device on a given platform |
|
Information about the active paint engine's current state |
|
All the information required to draw text in a custom paint engine |
|
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 |
|
Class to generate PDFs that can be used as a paint device |
|
Defines how a QPainter should draw lines and outlines of shapes |
|
Vector of points using integer precision |
|
Vector of points using floating point precision |
|
Specifies a clip region for a painter |
|
Struct contains a 64-bit RGB color |
|
Specifies 2D transformations of a coordinate system |
|
Abstract base class used to implement custom layouts for QTextDocuments |
|
Allows drawing of custom text objects in QTextDocuments |
|
Specifies a font used for drawing text |
|
Information about the fonts available in the underlying window system |
|
General information about fonts |
|
Font metrics information |
|
Font metrics information |
|
Direct access to the internal glyphs in a font |
|
Access to a single physical instance of a font |
|
Enables optimized drawing of text when the text and its layout is updated rarely |
|
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 |
|
Offers an API to access and modify QTextDocuments |
|
Holds formatted text |
|
Represents a piece of formatted text from a QTextDocument |
|
Format-independent interface for writing a QTextDocument to files or other devices |
|
Formatting information for blocks of text in a QTextDocument |
|
Formatting information for characters in a QTextDocument |
|
Formatting information for a QTextDocument |
|
Formatting information for frames in a QTextDocument |
|
Formatting information for images in a QTextDocument |
|
Encapsulates the different types of length used in a QTextDocument |
|
Formatting information for lists in a QTextDocument |
|
Formatting information for table cells in a QTextDocument |
|
Formatting information for tables in a QTextDocument |
|
Represents an inline object in a QAbstractTextDocumentLayout and its implementations |
|
Used to lay out and render text |
|
Represents a line of text inside a QTextLayout |
|
Decorated list of items in a QTextDocument |
|
Container for text fragments in a QTextDocument |
|
Container for text blocks within a QTextDocument |
|
Used to associate custom data with blocks of text |
|
Holds a piece of text in a QTextDocument with a single QTextCharFormat |
|
Represents a frame in a QTextDocument |
|
Base class for different kinds of objects that can group parts of a QTextDocument together |
|
Description of general rich text properties |
|
Represents a table in a QTextDocument |
|
Represents the properties of a cell in a QTextTable |
|
Methods for accessing common desktop services |
|
Range checking of floating-point numbers |
|
Validator that ensures a string contains a valid integer within a specified range |
|
Used to check a string against a regular expression |
|
Used to check a string against a regular expression |
|
Validation of input text |
|
Represents information about a Vulkan extension |
|
A specialized QVector for QVulkanLayer and QVulkanExtension |
|
Represents a native Vulkan instance, enabling Vulkan rendering onto a QSurface |
|
Represents information about a Vulkan layer |
|
Enables hardware acceleration of painting operations in Qt for Embedded Linux |
|
Convenience subclass of QWindow to perform Vulkan rendering |
|
Used to implement the application-specific rendering logic for a QVulkanWindow |
|
Used when registering fonts with the internal Qt fontdatabase |
|
The interface for cache implementations |
|
Cache information |
|
Specifies that a host supports HTTP Strict Transport Security policy (HSTS) |
|
Resembles a MIME multipart message to be sent over HTTP |
|
Holds a body part to be used inside a HTTP multipart MIME message |
|
Allows the application to send network requests and receive replies |
|
Holds one network cookie |
|
Implements a simple jar of QNetworkCookie objects |
|
Very basic disk cache |
|
Contains the data and headers for a request sent with QNetworkAccessManager |
|
Holds a request to be sent with QNetworkAccessManager |
|
Manages the network configurations provided by the system |
|
Abstraction of one or more access point configurations |
|
Control over the system's access points and enables session management for cases when multiple clients access the same access point |
|
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 |
|
IP address |
|
Static functions for host name lookups |
|
The data and metadata of a UDP datagram |
|
Stores one IP address supported by a network interface, along with its associated netmask and broadcast address |
|
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 |
|
The base functionality common to all socket types |
|
Local socket based server |
|
Local socket |
|
SCTP-based server |
|
SCTP socket |
|
TCP-based server |
|
TCP socket |
|
UDP socket |
|
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 |
|
Base implementation for print dialogs used to configure printers |
|
Defines an interface for how QPrinter interacts with a given printing subsystem |
|
Paint device that paints on a printer |
|
Gives access to information about existing printers |
|
Handles a connection to a database |
|
Template class that provides a SQL driver factory for a specific driver type |
|
The base class for SQL driver factories |
|
Abstract base class for accessing specific SQL databases |
|
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 |
|
Encapsulates a database record |
|
Abstract interface for accessing data from specific SQL databases |
|
Read-only data model for SQL result sets |
|
Delegate that is used to display and edit data from a QSqlRelationalTableModel |
|
Stores information about an SQL foreign key |
|
Editable data model for a single database table, with foreign key support |
|
Editable data model for a single database table |
|
List of GUI events |
|
Used to simulate a sequence of touch events |
|
Implements the QAccessibleInterface for QWidgets |
|
Data model for the local filesystem |
|
Blur effect |
|
Colorize effect |
|
Drop shadow effect |
|
The base class for all graphics effects |
|
Opacity effect |
|
Represents an anchor between two items in a QGraphicsAnchorLayout |
|
Layout where one can anchor widgets together in Graphics View |
|
Grid layout for managing widgets in Graphics View |
|
Common base for all path items |
|
Ellipse item that you can add to a QGraphicsScene |
|
The base class for all graphical items in a QGraphicsScene |
|
Container that treats a group of items as a single item |
|
Line item that you can add to a QGraphicsScene |
|
Base class for all graphics items that require signals, slots and properties |
|
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 |
|
Rectangle item that you can add to a QGraphicsScene |
|
Simple text path item that you can add to a QGraphicsScene |
|
Text item that you can add to a QGraphicsScene to display formatted text |
|
The base class for all layouts in Graphics View |
|
Can be inherited to allow your custom items to be managed by layouts |
|
Horizontal or vertical layout for managing widgets in Graphics View |
|
Proxy layer for embedding a QWidget in a QGraphicsScene |
|
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 |
|
Rotation transformation around a given axis |
|
Scale transformation |
|
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 |
|
Used to display and edit data items from a model |
|
The basic functionality for item view classes |
|
Model/view implementation of a column view |
|
Mapping between a section of a data model to widgets |
|
File icons for the QDirModel and the QFileSystemModel classes |
|
Header row or header column for item views |
|
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 |
|
The possibility to register widgets without having to subclass QItemEditorCreatorBase |
|
List or icon view onto a model |
|
Item-based list widget |
|
Item for use with the QListWidget item view class |
|
Display and editing facilities for data items from a model |
|
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 |
|
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 |
|
Abstract user interface action that can be inserted into widgets |
|
Groups actions together |
|
Manages the GUI application's control flow and main settings |
|
Lines up child widgets horizontally or vertically |
|
Lines up widgets horizontally |
|
Lines up widgets vertically |
|
Manages forms of input widgets and their associated labels |
|
Represents a gesture, containing properties that describe the corresponding user input |
|
The description of triggered gestures |
|
Describes a panning gesture made by the user |
|
Describes a pinch gesture made by the user |
|
Describes a swipe gesture made by the user |
|
Describes a tap-and-hold (aka LongTap) gesture made by the user |
|
Describes a tap gesture made by the user |
|
The infrastructure for gesture recognition |
|
Lays out widgets in a grid |
|
The base class of geometry managers |
|
Abstract item that a QLayout manipulates |
|
Blank space in a layout |
|
Layout item that represents a widget |
|
Widget for rendering OpenGL graphics |
|
Used to create keyboard shortcuts |
|
Layout attribute describing horizontal and vertical resizing policy |
|
Stack of widgets where only one widget is visible at a time |
|
Tool tips (balloon help) for any widget |
|
Simple description of any widget, i.e. answering the question "What's This?" |
|
The base class of all user interface objects |
|
Extends QAction by an interface for inserting custom widgets into action based containers, such as toolbars |
|
Transition for key events |
|
Transition for mouse events |
|
Encapsulates the common Look and Feel of a GUI |
|
The rules used to draw a pixmap or image split into nine segments |
|
Convenience class that simplifies dynamically overriding QStyle elements |
|
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 |
|
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 |
|
Maps device independent QColors to device dependent pixel values |
|
Completions based on an item model |
|
Enables kinetic scrolling for any scrolling widget or graphics item |
|
Stores the settings for a QScroller |
|
Icon for an application in the system tray |
|
Group of QUndoStack objects |
|
The base class of all commands stored on a QUndoStack |
|
Stack of QUndoCommand objects |
|
Displays the contents of a QUndoStack |
|
The abstract base class of button widgets, providing functionality common to buttons |
|
Scrolling area with on-demand scroll bars |
|
Integer value within a range |
|
Spinbox and a line edit to display values |
|
Container to organize groups of button widgets |
|
Monthly based calendar widget allowing the user to select a date |
|
Checkbox with a text label |
|
Combined button and popup list |
|
Vista style command link button |
|
Widget for editing dates based on the QDateTimeEdit widget |
|
Widget for editing dates and times |
|
Widget for editing times based on the QDateTimeEdit widget |
|
Rounded range control (like a speedometer or potentiometer) |
|
Widget that presents buttons in a layout that is appropriate to the current widget style |
|
Widget that can be docked inside a QMainWindow or floated as a top-level window on the desktop |
|
Focus frame which can be outside of a widget's normal paintable area |
|
Combobox that lets the user select a font family |
|
The base class of widgets that can have a frame |
|
Group box frame with a title |
|
Allows to input a QKeySequence |
|
Text or image display |
|
Displays a number with LCD-like digits |
|
One-line text editor |
|
Main application window |
|
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 |
|
Implements a plain text layout for QTextDocument |
|
Widget that is used to edit and display plain text |
|
Horizontal or vertical progress bar |
|
Command button |
|
Radio button with a text label |
|
Rectangle or line that can indicate a selection or a boundary |
|
Scrolling view onto another widget |
|
Vertical or horizontal scroll bar |
|
Resize handle for resizing top-level windows |
|
Vertical or horizontal slider |
|
Spin box widget that takes doubles |
|
Spin box widget |
|
Splash screen that can be shown during application startup |
|
Implements a splitter widget |
|
Handle functionality for the splitter |
|
Stack of widgets where only one widget is visible at a time |
|
Horizontal bar suitable for presenting status information |
|
Tab bar, e.g. for use in tabbed dialogs |
|
Stack of tabbed widgets |
|
Rich text browser with hypertext navigation |
|
Widget that is used to edit and display both plain and rich text |
|
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 |
|
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 |
|
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 |
|
Helper data type for QFlags |
|
Type-safe way of storing OR-combinations of enum values |
|
Used to implement a global static object |
|
Information about the Qt library |
|
Information about the operating system version |
|
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 |
|
Information about the system |
|
The base class of D-Bus adaptor classes |
|
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 |
|
Enables the programmer to identify the OBJECT_PATH type provided by the D-Bus typesystem |
|
Enables the programmer to identify the SIGNATURE type provided by the D-Bus typesystem |
|
Enables the programmer to identify the variant type provided by the D-Bus typesystem |
|
Proxy for interfaces on remote objects |
|
Represents one message sent or received over the D-Bus bus |
|
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 |
|
Holds one Unix file descriptor |
|
Used to handle several DBus paths with one class |
|
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.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 |
|
Cross-platform access to the device level core Vulkan 1.0 API |
|
Cross-platform access to the instance level core Vulkan 1.0 API |
|
Authentication object |
|
Inline class containing miscellaneous functionality for NSWindow and NSView window specific functionality |
|
Inline class containing platform-specific functionality for the eglfs platform plugin that is typically used on systems running Embedded Linux or Android |
|
A class encapsulating a Cocoa NSOpenGLContext |
|
A class encapsulating an EGL context and display handle |
|
A class encapsulating a GLXContext and related native handles |
|
A class encapsulating a WGL context on Windows with desktop OpenGL (opengl32.dll) |
|
Inline class containing miscellaneous functionality for Windows window specific functionality |
|
Inline class containing miscellaneous functionality for xcb window specific functionality |
|
Configuration dialog for the page-related options on a printer |
|
Dialog for specifying the printer's configuration |
|
Dialog for previewing and configuring page layouts for printer output |
|
Widget for previewing page layouts for printer output |
|
Helps testing QAbstractItemModel subclasses |
|
Enables introspection of signal emission |
|
Dialog widget for specifying colors |
|
The base class of dialog windows |
|
Error message display dialog |
|
Dialog that allow users to select files or directories |
|
Dialog widget for selecting a font |
|
Simple convenience dialog to get a single value from the user |
|
Modal dialog for informing the user or for asking the user a question and receiving an answer |
|
Feedback on the progress of a slow operation |
|
Framework for wizards |
|
The base class for wizard pages |
|
Widget for macOS that can be used to wrap arbitrary Cocoa views (i.e., NSView subclasses) and insert them into Qt hierarchies |
|
Widget for macOS that provides a way to put Qt widgets into Cocoa hierarchies |
|
Adds categories to a chart's axes |
|
Places named ranges on the axis |
|
Adds dates and times to a chart's axis |
|
Adds a logarithmic scale to a chart's axis |
|
Base class used for specialized axis classes |
|
Presents a series of data as horizontal bars grouped by category |
|
Presents a series of categorized data as a percentage of each category |
|
Presents a series of data as horizontally stacked bars, with one bar per category |
|
Abstract parent class for all bar series classes |
|
Presents a series of data as vertical bars grouped by category |
|
Presents a series of categorized data as a percentage of each category |
|
Presents a series of data as vertically stacked bars, with one bar per category |
|
Abstract model mapper class for candlestick series |
|
Represents a single candlestick item in a candlestick chart |
|
Presents data in line charts |
|
Manages the graphical representation of the chart's series, legends, and axes |
|
Standalone widget that can display charts |
|
Presents data in scatter charts |
|
Presents data as spline charts |
|
Presents data in area charts |
|
Adds values to a chart's axes |
|
Represents one set of bars in a bar chart |
|
Horizontal model mapper for bar series |
|
Vertical model mapper for bar series |
|
Presents data in box-and-whiskers charts |
|
Represents one item in a box-and-whiskers chart |
|
Horizontal model mapper for box plot series |
|
Vertical model mapper for box plot series |
|
Presents data as candlesticks |
|
Horizontal model mapper for a candlestick series |
|
Vertical model mapper for a candlestick series |
|
Legend marker for an area series |
|
Legend marker for a bar series |
|
Legend marker for a box plot series |
|
Legend marker for a candlestick series |
|
Displays the legend of a chart |
|
Abstract object that can be used to access markers within a legend |
|
Legend marker for a pie series |
|
Legend marker for a line, spline, or scatter series |
|
Horizontal model mapper for pie series |
|
Presents data in pie charts |
|
Represents a single slice in a pie series |
|
Vertical model mapper for pie series |
|
Base class for all Qt Chart series |
|
Presents data in polar charts |
|
Horizontal model mapper for line, spline, and scatter series |
|
Vertical model mapper for line, spline, and scatter series |
|
Base class for line, spline, and scatter series |
|
Assigns an address to the Bluetooth device |
|
Discovers the Bluetooth devices nearby |
|
Encapsulates the details of a local QBluetooth device |
|
Enables access to the local Bluetooth device |
|
Uses the RFCOMM or L2cap protocol to communicate with a Bluetooth device |
|
Transfers data to another device using Object Push Profile (OPP) |
|
Represents the data to be broadcast during Bluetooth Low Energy advertising |
|
Used to set up GATT service data |
|
Filter for matching NDEF messages |
|
NFC NDEF message |
|
Manages all interactions related to sharing files and data over NFC |
|
Stores information about the Bluetooth device |
|
Enables you to query for Bluetooth services |
|
Enables access to the attributes of a Bluetooth service |
|
Enables connection to a Bluetooth device running a bluetooth server |
|
Stores the response for a data transfer request |
|
Stores information about a data transfer request |
|
Generates a UUID for each Bluetooth service |
|
Represents the parameters used for Bluetooth Low Energy advertising |
|
Stores information about a Bluetooth Low Energy service characteristic |
|
Used to set up GATT service data |
|
Used when requesting or reporting an update of the parameters of a Bluetooth LE connection |
|
Access to Bluetooth Low Energy Devices |
|
Stores information about the Bluetooth Low Energy descriptor |
|
Used to create GATT service data |
|
Represents an individual service on a Bluetooth Low Energy Device |
|
NFC RTD-SmartPoster |
|
NFC RTD-Text |
|
NFC RTD-URI |
|
NFC NDEF record |
|
Access to notifications for NFC events |
|
Transfers data to remote device over NFC |
|
Interface for communicating with a target device |
|
Implements the NdefRecord type in QML |
|
Adds a custom item to a graph |
|
Basic wheel mouse based input handler |
|
Base class for the axes of a graph |
|
Manipulates an axis of a graph |
|
Formatting rules for a logarithmic value axis |
|
Manipulates an axis of a graph |
|
Base class for value axis formatters |
|
Base class for all data series |
|
Base class for all data visualization data proxies |
|
Represents a data series in a 3D bar graph |
|
Container for resolved data to be added to bar graphs |
|
The data proxy for a 3D bars graph |
|
Adds a custom label to a graph |
|
Adds a volume rendered object to a graph |
|
Base proxy class for Q3DSurface |
|
Proxy class for presenting data in item models with Q3DBars |
|
Proxy class for presenting data in item models with Q3DScatter |
|
Proxy class for presenting data in item models with Q3DSurface |
|
Represents a data series in a 3D scatter graph |
|
Container for resolved data to be added to scatter graphs |
|
The data proxy for 3D scatter graphs |
|
Represents a data series in a 3D surface graph |
|
Container for resolved data to be added to surface graphs |
|
The data proxy for a 3D surface graph |
|
Methods for rendering 3D bar graphs |
|
Representation of a camera in 3D space |
|
Representation of a light source in 3D space |
|
Simple base class for all the objects in a 3D scene |
|
Methods for rendering 3D scatter graphs |
|
Description of the 3D scene being visualized |
|
Methods for rendering 3D surface plots |
|
Window and render loop for graphs |
|
Base class for implementations of input handlers |
|
Basic touch display based input handler |
|
Visual style for graphs |
|
Environment for evaluating JavaScript code |
|
Acts as a container for Qt/JavaScript data types |
|
Java-style iterator for QJSValue |
|
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 |
|
Used to register image providers in the QML engine |
|
Encapsulates a QML error |
|
Evaluates JavaScript in a QML context |
|
Abstract base for custom QML extension plugins |
|
A class for applying a QFileSelector to QML file loading |
|
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 |
|
Interface for property value sources such as animations and bindings |
|
Encapsulates a script and its context |
|
Allows you to set key-value pairs that can be used in QML bindings |
|
Convenience class for integrating OpenGL rendering using a framebuffer object (FBO) with Qt Quick |
|
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 |
|
Access to the QTextDocument of QQuickTextEdit |
|
Window for displaying a Qt Quick user interface |
|
The window for displaying a graphical QML scene |
|
Gives access to the scene graph nodes and rendering of a QSGEngine |
|
Low-level storage for graphics primitives in the Qt Quick Scene Graph |
|
Encapsulates rendering state for a shader program |
|
Represents an OpenGL shader program in the renderer |
|
Used as a unique type token in combination with QSGMaterial |
|
Serves as a baseclass for geometry based nodes |
|
Implements the clipping functionality in the scene graph |
|
Used for all rendered content in the scene graph |
|
The base class for all nodes in the scene graph |
|
Used to change opacity of nodes |
|
Implements transformations in the scene graph |
|
An interface providing access to some of the graphics API specific internals of the scenegraph |
|
Represents a set of custom rendering commands targeting the graphics API that is in use by the scenegraph |
|
Allows low level rendering of a scene graph |
|
Convenient way of rendering solid colored geometry in the scene graph |
|
Provided for convenience to easily draw textured content using the QML scene graph |
|
Convenience class for drawing solid filled rectangles using scenegraph |
|
Template generated class used to store the state used with a QSGSimpleMateralShader |
|
Convenient way of building custom OpenGL-based materials for the scene graph |
|
Serves as a baseclass for dynamically changing textures, such as content that is rendered to FBO's |
|
Baseclass for textures used in the scene graph |
|
Convenient way of rendering textured geometry in the scene graph |
|
Convenient way of rendering textured geometry in the scene graph |
|
Encapsulates texture based entities in QML |
|
Convenient way of rendering per-vertex colored geometry in the scene graph |
|
Interface for for asynchronous control of QML image requests |
|
Interface for supporting pixmaps and threaded image requests in QML |
|
Interface for asynchronous image loading in QQuickAsyncImageProvider |
|
Interface for loading custom textures from QML |
|
Widget for displaying a Qt Quick user interface |
|
A gamepad device connected to a system |
|
Provides support for keyboard events triggered by gamepads |
|
Queries attached gamepads and related events |
|
Manages an operation started by an instance of QGeoCodingManager |
|
Represents the information relevant to the point at which two QGeoRouteSegments meet |
|
Represents a route between two points |
|
Manages an operation started by an instance of QGeoRoutingManager |
|
Represents a segment of a route |
|
Aggregates access to services which provide geographical information |
|
Represents a set of data about a place |
|
Manages a content retrieval operation started by an instance of QPlaceManager |
|
Manages a place details fetch operation started by an instance of QPlaceManager |
|
Represents an icon |
|
Manages operations which return an identifier such as saving and removal operations of places and categories |
|
The interface which allows clients to access places stored in a particular backend |
|
Represents an individual user |
|
Represents an address of a QGeoLocation |
|
Describes the parameters of an area or region to be monitored for proximity |
|
Enables the detection of proximity changes for a specified set of coordinates |
|
Represents basic information about a location |
|
Support for geocoding operations |
|
Interface and convenience methods to implementers of QGeoServiceProvider plugins who want to provide support for geocoding operations |
|
Represents the parameters and restrictions which define a request for routing information |
|
Support for geographic routing operations |
|
Interface and convenience methods to implementers of QGeoServiceProvider plugins who want to provide access to geographic routing information |
|
Factory class used as the plugin interface for services related to geographical information |
|
Represents generic attribute information about a place |
|
Represents a category that a QPlace can be associated with |
|
Represents a contact detail such as a phone number or website url |
|
Serves as the base class for rich content types |
|
Represents the parameters of a content request |
|
Represents a publisher's article describing a place |
|
Represents a reference to an image |
|
Interface for implementers of QGeoServiceProvider plugins who want to provide access to place functionality |
|
Manages a place matching operation started by an instance of QPlaceManager |
|
Used to find places from one manager that match those from another. It represents a set of request parameters |
|
Represents a search result containing a proposed search |
|
Holds rating information about a place |
|
Manages an operation started by an instance of QPlaceManager and serves as a base class for more specialized replies |
|
Represents a search result containing a place |
|
Represents a review of a place |
|
Manages a place search operation started by an instance of QPlaceManager |
|
Represents the set of parameters for a search request |
|
The base class for search results |
|
Manages a search suggestion operation started by an instance of QPlaceManager |
|
Represents a supplier of a place or content associated with a place |
|
Defines a circular geographic area |
|
Defines a geographical position on the surface of the Earth |
|
Defines a geographic path |
|
Defines a geographic polygon |
|
Contains information gathered on a global position, direction and velocity at a particular point in time |
|
Abstract base class for the distribution of positional updates |
|
Factory class used as the plugin interface for external providers of positioning data |
|
Defines a rectangular geographic area |
|
Contains basic information about a satellite |
|
Abstract base class for the distribution of satellite information updates |
|
Defines a geographic area |
|
Positional information using a NMEA data source |
|
Converts between a MIME type and a Uniform Type Identifier (UTI) format |
|
Wraps the native NSToolbar class |
|
Item for QMacToolBar |
|
Represents a collection of audio samples with a specific format and sample rate |
|
Allows decoding audio |
|
Interface to query audio devices and their functionality |
|
Interface for receiving audio data from an audio input device |
|
Interface for sending audio data to an audio output device |
|
Allows you to monitor audio being played or recorded |
|
Base class for audio backends |
|
Access for QAudioInput to access the audio device provided by the plugin |
|
Base class for audio backends |
|
Abstract base for audio plugins |
|
Method to play .wav sound files |
|
Way to play low latency sound effects |
|
Interface for exposure related camera settings |
|
Interface for focus and zoom related camera settings |
|
Information on zones used for autofocusing a camera |
|
Used for the recording of media content |
|
Interface for image processing related camera settings |
|
General information about camera devices |
|
Set of viewfinder settings |
|
Access to the audio decoding functionality of a QMediaService |
|
Access to the settings of a media service that performs audio encoding |
|
Audio input selector media control |
|
Audio output selector media control |
|
Control over the audio role of a media object |
|
Control for setting the capture buffer format |
|
Control for setting capture destination |
|
Abstract base class for classes that control still cameras or video cameras |
|
Allows controlling camera exposure parameters |
|
Allows controlling feedback (sounds etc) during camera operation |
|
Allows controlling a camera's flash |
|
Supplies control for focusing related camera parameters |
|
Control interface for image capture services |
|
Abstract class for controlling image processing parameters, like white balance, contrast, saturation, sharpening and denoising |
|
Camera info media control |
|
Abstract base class for classes that control still cameras or video cameras |
|
Abstract class for controlling camera viewfinder parameters |
|
Access to the viewfinder settings of a camera media service |
|
Supplies control for optical and digital camera zoom |
|
Control over the audio role of a media object |
|
Access to the settings of a media service that performs image encoding |
|
Allows control over probing audio data in media objects |
|
Supplies a control for reporting availability of a service |
|
Access to the output container format of a QMediaService |
|
Access to the gapless playback related control of a QMediaService |
|
Allows the setting of the Network Access Point for media related activities |
|
Access to the media playing functionality of a QMediaService |
|
Access to the recording functionality of a QMediaService |
|
Media stream selection control |
|
Allows control over probing video frames in media objects |
|
Read access to the meta-data of a QMediaService's media |
|
Write access to the meta-data of a QMediaService's media |
|
Access to the RDS functionality of the radio in the QMediaService |
|
Access to the radio tuning functionality of a QMediaService |
|
Video device selector media control |
|
Access to the settings of a media service that performs video encoding |
|
Media control for rendering video to a QAbstractVideoSurface |
|
Media control for rendering video to a window |
|
Access to the resources relating to a media content |
|
Allows the playing of a media source |
|
List of media content to play |
|
Description of a media resource |
|
The base class for objects extending media objects functionality |
|
Base interface for media service controls |
|
Common base for multimedia objects |
|
Common base class for media service implementations |
|
Interface provides camera-specific information about devices supported by a camera service plug-in |
|
Interface identifies the default device used by a media service plug-in |
|
Interface identifies features supported by a media service plug-in |
|
Interface provides an interface for QMediaService plug-ins |
|
Interface identifies the devices supported by a media service plug-in |
|
Interface identifies if a media service plug-in supports a media format |
|
Represents a time interval with integer precision |
|
Represents a set of zero or more disjoint time intervals |
|
Interfaces to the RDS functionality of the system radio |
|
Interface to the systems analog radio device |
|
Used for the recording of audio |
|
Set of audio encoder settings |
|
Set of image encoder settings |
|
Set of video encoder settings |
|
Used for the recording of media content |
|
Represents a filter that is applied to the video frames received by a VideoOutput type |
|
Represents the implementation of a filter that owns all graphics and computational resources, and performs the actual filtering or calculations |
|
Base class for video presentation surfaces |
|
Allows you to monitor video frames being played or recorded |
|
Specifies the stream format of a video presentation surface |
|
Camera viewfinder widget |
|
Graphics item which display video produced by a QMediaObject |
|
Widget which presents video produced by a media object |
|
Media control which implements a video widget |
|
Stores audio stream parameter information |
|
Interface for system camera devices |
|
Abstraction for planar video data |
|
Abstraction for video data |
|
Represents a frame of video data |
|
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 |
|
Implementation of the OAuth 1 Protocol |
|
Implements OAuth 1 signature methods |
|
Implementation of the Authorization Code Grant flow |
|
A product registered in the store |
|
Main entry point for managing in-app purchases |
|
Contains information about a transaction in the external app store |
|
Allows configuring the application style |
|
A dynamically instantiated Replica |
|
A class holding information about client backends available on the Qt Remote Objects network |
|
A class holding information about server backends available on the Qt Remote Objects network |
|
A class which provides the methods for setting PROP values of a replica to value they had the last time the replica was used |
|
A (Host) Node on a Qt Remote Objects network |
|
Base functionality common to Host and RegistryHost classes |
|
A node on a Qt Remote Objects network |
|
A (Host/Registry) node on a Qt Remote Objects network |
|
A class holding information about Source objects available on the Qt Remote Objects network |
|
A class interacting with (but not implementing) a Qt API on the Remote Object network |
|
Access to the Qt Script environment from Qt C++ member functions |
|
Interface for defining custom behavior of (a class of) Qt Script objects |
|
Iterator interface for custom Qt Script objects |
|
Represents a Qt Script function invocation |
|
Additional information about a QScriptContext |
|
Environment for evaluating Qt Script code |
|
The result of a script syntax check |
|
Interface to report events pertaining to QScriptEngine execution |
|
Abstract base for custom QScript extension plugins |
|
Encapsulates a Qt Script program |
|
Acts as a handle to "interned" strings in a QScriptEngine |
|
Acts as a container for the Qt Script data types |
|
Java-style iterator for QScriptValue |
|
QScriptEngine debugger |
|
Compiler for SCXML files |
|
C++ data model for a Qt SCXML state machine |
|
Event for a Qt SCXML state machine |
|
Creates SCXML service instances from documents loaded at runtime |
|
The base class for services called from state machines |
|
Creates invokable service instances |
|
Creates SCXML service instances from precompiled documents |
|
Interface to the state machines created from SCXML files |
|
Used by compiled state machines |
|
The data model base class for a Qt SCXML state machine |
|
The ECMAScript data model for a Qt SCXML state machine |
|
Describes the errors returned by the Qt SCXML state machine when parsing an SCXML file |
|
AssingmentInfo class represents a data assignment |
|
Represents a unit of executable content |
|
Represents a foreach construct |
|
Represents a service invocation |
|
Represents a parameter to a service invocation |
|
The null data model for a Qt SCXML stateMachine |
|
Represents one or more sensor gesture recognizers |
|
Manages sensor gestures, registers and creates sensor gesture plugins |
|
The pure virtual interface to sensor gesture plugins |
|
The base class for a sensor gesture recognizer |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Reports on linear acceleration along the X, Y and Z axes |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Holds readings from the altimeter sensor |
|
Convenience wrapper around QSensorFilter |
|
Represents one reading from the ambient light sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Holds readings of the ambient temperature |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Represents one reading from a compass |
|
Convenience wrapper around QSensorFilter |
|
Holds distance reading in cm from the proximity sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Represents one reading from the gyroscope sensor |
|
Convenience wrapper around QSensorFilter |
|
Holds readings from the holster sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Holds readings from the humidity sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Holds readings from the IR proximity sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Holds readings from the Lid sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Represents one reading from the light sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Represents one reading from the magnetometer |
|
Convenience wrapper around QSensorFilter |
|
Represents one reading from the orientation sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Holds readings from the pressure sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Represents one reading from the proximity sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Represents one reading from the rotation sensor |
|
Convenience wrapper around QSensor |
|
Represents a single hardware sensor |
|
Efficient callback facility for asynchronous notifications of sensor changes |
|
Holds the readings from the sensor |
|
Holds the specifics of an output range |
|
Sensor implementation |
|
Instantiates instances of QSensorBackend |
|
Handles registration and creation of sensor backends |
|
The pure virtual interface to sensor plugins |
|
The pure virtual interface to sensor plugins |
|
Convenience wrapper around QSensorFilter |
|
Represents one reading from the tap sensor |
|
Convenience wrapper around QSensor |
|
Convenience wrapper around QSensorFilter |
|
Holds readings from the tilt sensor |
|
Convenience wrapper around QSensor |
|
The interface to send Modbus requests |
|
Represents a Modbus client that uses a serial bus for its communication with the Modbus server |
|
Represents a Modbus server that uses a serial port for its communication with the Modbus client |
|
The interface class for Modbus TCP client device |
|
Represents a Modbus server that uses a TCP server for its communication with the Modbus client |
|
Handles registration and creation of bus plugins |
|
The interface class for CAN bus |
|
Information about CAN bus interfaces |
|
Factory class used as the plugin interface for CAN bus plugins |
|
Container class representing a single CAN frame |
|
Container class representing single bit and 16 bit word entries in the Modbus register |
|
The base class for Modbus classes, QModbusServer and QModbusClient |
|
Container class representing the physical and functional description of a Modbus server |
|
Container class containing the function and error code inside a Modbus ADU |
|
Abstract container class containing the function code and payload that is stored inside a Modbus ADU |
|
Container class containing the function code and payload that is stored inside a Modbus ADU |
|
Container class containing the function code and payload that is stored inside a Modbus ADU |
|
Contains the data for a request sent with a QModbusClient derived class |
|
The interface to receive and process Modbus requests |
|
Provides functions to access serial ports |
|
Provides information about existing serial ports |
|
QGraphicsItem that can be used to render the contents of SVG files |
|
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 |
|
Allows you to create a factory that is able to make instances of custom extensions in Qt Designer |
|
Extension management facilities for Qt Designer |
|
Allows you to change the focus of Qt Designer's action editor |
|
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 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 control the contents of Qt Designer's widget box |
|
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 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 |
|
Default implementation for classes that create user interfaces at run-time |
|
Used to dynamically construct user interfaces from UI files at run-time |
|
Access to widgets reusable to integrate fulltext search as well as to index and search documentation |
|
The data associated with the search result |
|
Allows you to include several custom widgets in one single library |
|
Enables Qt Designer to access and construct custom widgets |
|
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 |
|
Model that supplies index keywords to views |
|
List view displaying the QHelpIndexModel |
|
Simple line edit or an advanced widget to enable the user to input a search term in a standardized input mask |
|
Text browser to display search results |
|
Interface for extension factories in Qt Designer |
|
Interface for extension managers in Qt Designer |
|
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 add pages to a custom multi-page container in Qt Designer's workspace |
|
Allows you to manipulate a widget's dynamic properties in Qt Designer's property editor |
|
Enables standalone applications to dynamically create user interfaces at run-time using the information stored in UI files or specified in plugin paths |
|
Exposes QObjects to remote HTML clients |
|
Communication channel between the C++ QWebChannel server and a HTML/JS client |
|
Abstract base for custom 32-bit mask generators |
|
Implements a TCP socket that talks the WebSocket protocol |
|
Authenticator object for Cross Origin Requests (CORS) |
|
Implements a WebSocket-based server |
|
Callback interface for handling messages |
|
Callback interface for resolving Uniform Resource Identifiers. A Uniform Resource Identifier (URI) is a string that uniquely identifies a resource. URIs are versatile global identifiers. It is often useful to transform a URI that identifies something logical into a URI that locates something physical (a URL), or to simply map a URI to a different URI. QAbstractUriResolver::resolve() provides this functionality |
|
Abstract base class for modeling non-XML data to look like XML for QXmlQuery |
|
Contains either an XML node or an atomic value |
|
Identifies a node in an XML node model subclassed from QAbstractXmlNodeModel |
|
Implementation of QAbstractXmlNodeModel sufficient for many common cases |
|
Identifies a location in a resource by URI, line, and column |
|
Implementation of QXmlSerializer for transforming XQuery output into formatted XML |
|
Represents the name of an XML node, in an efficient, namespace-aware way. QXmlName represents the name of an XML node in a way that is both efficient and safe for comparing names. Normally, an XML node represents an XML element or attribute, but QXmlName can also represent the names of other kinds of nodes, e.g., QAbstractXmlReceiver::processingInstruction() and QAbstractXmlReceiver::namespaceBinding() |
|
Table of shared strings referenced by instances of QXmlName |
|
Performs XQueries on XML data, or on non-XML data modeled to look like XML |
|
Iterates through the results of evaluating an XQuery in QXmlQuery |
|
Loading and validation of a W3C XML Schema |
|
Validates XML instance documents against a W3C XML Schema |
|
Implementation of QAbstractXmlReceiver for transforming XQuery output into unformatted XML |