Annotated Class List

Representation of a camera in 3D space

Representation of a light source in 3D space

Methods for rendering 3D scatter graphs

Methods for rendering 3D surface plots

Base class for the axes of a graph

Base class for implementations of input handlers

The base of all animations

Abstract parent class for all bar series classes

Base class for all data visualization data proxies

Interface for extension factories in Qt Designer

File icons for the QFileSystemModel class

Common base for all path items

Used to display and edit data items from a model

Serves as a convenience class for Replicas of Sources based on QAbstractItemModel

The basic functionality for item view classes

Interface for receiving native events, such as MSG or XCB event structs

The base of all implementations of OAuth authentication methods

Handles replies to OAuth authentication requests

Base implementation for print dialogs used to configure printers

Scrolling area with on-demand scroll bars

Integer value within a range

Spinbox and a line edit to display values

Abstract model that can be subclassed to create table models

The base class of transitions between QAbstractState objects

Convenience wrapper around QSensorFilter

Enums and static functions related to accessibility

Implements support for objects with editable text

Defines an interface that exposes information about accessible objects

Abstract base class for plugins provinding accessibility information for user interface elements

Implements support for the IAccessibleTable2 Cell 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 text being inserted

Notifies of text being deleted

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

Implements support for objects that manipulate a value

Abstraction for user commands that can be added to different user interface components

Groups actions together

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

Wraps the most important methods of Android Binder class

Wraps the most important methods of Android Parcel class

Wraps the most important methods of Android ServiceConnection class

Unified view on Latin-1, UTF-8, or UTF-16 strings with a read-only subset of the QString API

Legend marker for an area series

Iterable interface for an associative container in a QVariant

Platform-independent atomic operations on integers

Represents a collection of audio samples with a specific format and sample rate

Information about audio devices and their functionality

Stores audio stream parameter information

Defines the position and orientation of the person listening to a sound field defined by QAudioEngine

Interface for receiving audio data from an audio input device

Abstract base class for implementations of additional COM interfaces

Static properties and signals for QAxObject

Interface between a QWidget and an ActiveX client

QObject that wraps a COM object

Wrapper around script code

Bridge between application objects and script code

QWidget that wraps an ActiveX control

Drawing area for QWindow

Adds categories to a chart's axes

The data proxy for a 3D bars graph

Presents a series of data as vertical bars grouped by category

Wrapper class around binding-enabled properties. It allows type-safe operations while abstracting the differences between the various property classes away

Monochrome (1-bit depth) pixmaps

Discovers the Bluetooth devices nearby

Encapsulates the details of a local QBluetooth device

Uses the RFCOMM or L2cap protocol to communicate with a Bluetooth device

Enables access to the attributes of a Bluetooth service

Generates a UUID for each Bluetooth service

Legend marker for a box plot series

Represents one item in a box-and-whiskers chart

QIODevice interface for a QByteArray

Array of bytes

Holds a sequence of bytes that can be quickly matched in a byte array

Template class that provides a cache

Monthly based calendar widget allowing the user to select a date

General information about camera devices

Handles registration and creation of bus plugins

Information about CAN bus interfaces

Container class representing a single CAN frame

Abstract model mapper class for candlestick series

Represents a single candlestick item in a candlestick chart

Places named ranges on the axis

Holds the error condition found while parsing or validating a CBOR stream

Used by QCborValue to report a parsing error

Simple CBOR encoder operating on a one-way stream

16-bit Unicode character

Standalone widget that can display charts

Contains event parameters for child object events

Contains parameters that describe a close event

Holds information about a CoAP message that can be a request or a reply

Interface for managing CoAP security keys

Holds a CoAP request. This request can be sent with QCoapClient

Holds the data of a CoAP reply for a resource discovery request

Compares strings according to a localized collation algorithm

Colors based on RGB, HSV or CMYK values

Dialog widget for specifying colors

Transformation between color spaces

Model/view implementation of a column view

Defines a possible command-line option

Vista style command link button

Convenience wrapper around QSensor

Represents one reading from a compass

Access to the details about a compressed help file

Used in combination with QBrush to specify a conical gradient brush

Contains parameters that describe a context menu event

Event loop for Qt applications without UI

Mouse cursor with an arbitrary shape

Adds a custom label to a graph

The base class of D-Bus adaptor classes

Used to marshall and demarshall D-Bus arguments

Access to the D-Bus bus daemon service

Represents an error received from the D-Bus bus or from remote applications found in the bus

Represents one message sent or received over the D-Bus bus

Refers to one pending asynchronous call

Contains the reply to an asynchronous method call

Peer-to-peer communication between processes on the same computer

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

Serialization of binary data to a QIODevice

Date functions

Date and time functions

Widget for editing dates and times

Output stream for debugging information

Allows you to change the focus of Qt Designer's action editor

Allows you to include several custom widgets in one single library

Allows you to manipulate a widget's dynamic properties in Qt Designer's property editor

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 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 manipulate a widget's properties which is displayed in Qt Designer's property editor

Allows you to control the contents of Qt Designer's widget box

Rounded range control (like a speedometer or potentiometer)

Widget that presents buttons in a layout that is appropriate to the current widget style

Iterator for directory entrylists

Stores information about a host address record

Stores information about a DNS MX record

Stores information about a DNS TXT record

Represents one attribute of a QDomElement

Represents a generic string in the DOM

Represents an XML document

The representation of the DTD in the document tree

Represents an XML entity

Information about the features of the DOM implementation

The base class for all the nodes in a DOM tree

Represents an XML notation

Represents text data in the parsed XML document

Range checking of floating-point numbers

Event which is sent to a widget when a drag and drop action enters it

Event which is sent while a drag and drop action is in progress

This class provides encryption for UDP sockets

Contains event parameters for dynamic property change events

Fast way to calculate elapsed times

Contains parameters that describe an enter event

The base class of all event classes. Event objects contain event parameters

Means to quit an event loop when it is no longer needed

QObject-specific transition for Qt events

Represents a pointer to an explicitly shared object

Allows you to create a factory that is able to make instances of custom extensions in Qt Designer

Interface for reading from and writing to files

Dialog that allow users to select files or directories

System-independent file information

Convenient way of selecting file variants

Interface for monitoring files and directories for modifications

Helper data type for QFlags

Contains event parameters for widget focus events

Specifies a query for a font used for drawing text

Information about the fonts available in the underlying window system

General information about fonts

Font metrics information

Manages forms of input widgets and their associated labels

Represents the result of an asynchronous computation

Convenience class that simplifies QFuture synchronization

Internal helper class for marshalling arguments

Abstract base class for plugins

Internal helper class for marshalling arguments

Describes the parameters of an area or region to be monitored for proximity

Defines a circular geographic area

Represents basic information about a location

Defines a geographic polygon

Abstract base class for the distribution of positional updates

Defines a rectangular geographic area

Abstract base class for the distribution of satellite information updates

Represents a gesture, containing properties that describe the corresponding user input

The infrastructure for gesture recognition

Direct access to the internal glyphs in a font

Represents an anchor between two items in a QGraphicsAnchorLayout

Blur effect

Drop shadow effect

Ellipse item that you can add to a QGraphicsScene

The base class for all graphical items in a QGraphicsScene

The base class for all layouts in Graphics View

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

Polygon item that you can add to a QGraphicsScene

Rectangle item that you can add to a QGraphicsScene

Scale transformation

Context menu events in the graphics view framework

Base class for all graphics view related events

Hover events in the graphics view framework

Events for widget moving in the graphics view framework

Wheel events in the graphics view framework

QGraphicsItem that can be used to render the contents of SVG files

Abstract base class for building advanced transformations on QGraphicsItems

Widget for displaying the contents of a QGraphicsScene

Implements the Gregorian calendar

Group box frame with a title

Convenience wrapper around QSensor

Represents one reading from the gyroscope sensor

Lines up widgets horizontally

Horizontal model mapper for a candlestick series

Horizontal model mapper for line, spline, and scatter series

Java-style const iterator for QHash and QMultiHash

Header row or header column for item views

Item for use with QHelpContentModel

Tree view for displaying help content model items

The core functionality of the help system

Details for the filters used by QHelpFilterEngine

Widget that allows for creating, editing and removing filters

List view displaying the QHelpIndexModel

Access to widgets reusable to integrate fulltext search as well as to index and search documentation

The data associated with the search result

Event which is sent after a widget is hidden

Presents a series of data as horizontal bars grouped by category

Presents a series of data as horizontally stacked bars, with one bar per category

Static functions for host name lookups

Specifies that a host supports HTTP Strict Transport Security policy (HSTS)

Resembles a MIME multipart message to be sent over HTTP

Simplified API for QAbstractHttpServer and QHttpServerRouter

API for sending replies from an HTTP server

Provides functions to bind a URL to a ViewHandler

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

Base class for QIODevice that provides flags describing the mode in which a device is opened

Indicates that a main icon drag has begun

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

Format independent interface for reading images from files or other devices

Describes a device from which a QInputEvent originates

The base class for events that describe user input

Parameters for input method events

Validator that ensures a string contains a valid integer within a specified range

Makes it possible to create item editor creator bases without subclassing QItemEditorCreatorBase

Widgets for editing item data in views and delegates

Proxy class for presenting data in item models with Q3DScatter

Manages information about selected items in a model

Manages information about a range of selected items in a model

Template class that allows iteration over a container in a QVariant

Represents a value on the JavaScript heap belonging to a QJSEngine

An empty marker type to signify the JavaScript Undefined type and its single value

Acts as a container for Qt/JavaScript data types

Jalali (Hijri Shamsi) calendar system implementation

A convenience wrapper around the Java Native Interface (JNI)

Way to read and write JSON documents

Used to report errors during JSON parsing

Julian calendar system implementation

Describes a key event

Encapsulates a key sequence as used by shortcuts

Iterator over the key/value pairs of an associative container

Platform-independent little-endian integers

8-bit ASCII/Latin-1 character

Thin wrapper around an US-ASCII/Latin-1 encoded string literal

Abstract item that a QLayout manipulates

Abstract object that can be used to access markers within a legend

Information about the Qt library

Represents one reading from the light sensor

Two-dimensional vector using integer precision

Two-dimensional vector using floating point precision

Used in combination with QBrush to specify a linear gradient brush

Java-style const iterator for QLinkedList

Java-style const iterator for QList and QQueue

Item-based list widget

Local socket based server

Converts between numbers and their string representations in various languages

Formatting rules for a logarithmic value axis

Represents a category, or 'area' in the logging infrastructure

Represents the parameters used for Bluetooth Low Energy advertising

Used to set up GATT service data

Access to Bluetooth Low Energy Devices

Used to create GATT service data

Used to set up GATT service data

Convenience wrapper around QSensorFilter

Main application window

Java-style const iterator for QMap

Defines the four margins of a rectangle

Represents a 4x4 transformation matrix in 3D space

Subwindow class for QMdiArea

Information about available multimedia input and output devices

Provides meta-data for media files

Used for encoding and recording a capture session

Menu widget for use in menu bars, context menus, and other popup menus

Way to generate hash-based message authentication codes

Additional information about a log message

Additional information about a class

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

Describes types of file or data, represented by a MIME type string

Container class representing single bit and 16 bit word entries in the Modbus register

Container class representing the physical and functional description of a Modbus server

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

Represents a Modbus client that uses a serial bus for its communication with the Modbus server

The interface to receive and process Modbus requests

Represents the interface for objects that can be passed to QModbusTcpServer::installConnectionObserver

Used to locate data in a data model

Span over QModelRoleData objects

Transition for mouse events

Convenience class for playing movies with QImageReader

Represents the central access communicating with an MQTT broker

Represents configuration options a QMqttClient can pass to the server when specifying the last will during connecting to a server

Represents additional information provided by the server during message delivery

Represents configuration options of a server a QMqttClient is connected to

Receives notifications from an MQTT broker about a specified topic

Represents a MQTT topic filter

Represents configuration options a QMqttClient can pass to the server when unsubscribing from a topic filter

Convenience QHash subclass that provides multi-valued hashes

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 QLinkedList

Java-style non-const iterator for QMap

Java-style non-const iterator for QSet

Convenience class that simplifies locking and unlocking mutexes

Native interface to a core application on Android

Native interface to an NSOpenGLContext on macOS

Native interface to a GLX context

Provides access to and enables adopting Metal texture objects

Provides access to and enables adopting Vulkan image objects

Native interface to an X11 application

NFC NDEF message

NFC RTD-SmartPoster

NFC RTD-URI

Access to notifications for NFC events

Allows the application to send network requests and receive replies

Cache information

Implements a simple jar of QNetworkCookie objects

Very basic disk cache

Listing of the host's IP addresses and network interfaces

Fine-grained proxy selection

Contains the data and headers for a request sent with QNetworkAccessManager

Positional information using a NMEA data source

Implementation of the OAuth 1 Protocol

Implementation of the Authorization Code Grant flow

Template class that enables automatic property bindings for property data stored in QObject derived classes

Template class to help port old properties to the bindable property system

Represents an offscreen surface in the underlying platform

This class stores the necessary information to add a new reference on the server

Defines the identity of the application

OPC UA Argument type

OPC UA authentication information

Partial implementation of the OPC UA binary data encoding described in OPC-UA part 6

Contains parameters for a call to the OPC UA browse service

OPC UA ComplexNumber type

OPC UA ContentFilterElementResult

This class stores the necessary information to delete a reference from the server

OPC UA EURange type

OPC UA EndpointDescription

OPCUA EventFilterResult

OPC UA ExtensionObject

This class stores historical data values from a node

This class is used for requesting historical data and storing the results

OPC UA LiteralOperand type

Way to set and retrieve parameters for subscriptions and monitored items

Allows interaction with an OPC UA node

Defines the PKI configuration of the application

OPC UA QualifiedName type

This class stores the options for a read operation

Contains information about a node

OPC UA SimpleAttributeOperand type

This class stores the options for a write operation

Create a certificate signing request

Base class for all X509 extensions

Class for X509 extended key usage

Class for an X509 subject alternative name

Functions for creating and managing OpenGL buffer objects

Represents a group of contexts sharing OpenGL resources

Wraps an OpenGL debug message

Encapsulates an OpenGL framebuffer object

Cross-platform access to the OpenGL ES 2.0 API

All functions for OpenGL 1.1 specification

All functions for OpenGL 1.3 specification

All functions for OpenGL 1.5 specification

All functions for OpenGL 2.1 specification

All functions for OpenGL 3.1 specification

All functions for OpenGL 3.2 core profile

All functions for OpenGL 3.3 core profile

All functions for OpenGL 4.0 core profile

All functions for OpenGL 4.1 core profile

All functions for OpenGL 4.2 core profile

All functions for OpenGL 4.3 core profile

All functions for OpenGL 4.4 core profile

All functions for OpenGL 4.5 core profile

Enables painting to an OpenGL context using QPainter

Allows OpenGL shaders to be compiled

Encapsulates an OpenGL texture object

Wraps a sequence of OpenGL timer query objects

Provides access to OpenGL functions for a specified version and profile

Wraps an OpenGL Vertex Array Object

Convenience subclass of QWindow to perform OpenGL painting

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

Represents a collection of page ranges

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

Contains event parameters for paint events

Container for painting operations, enabling graphical shapes to be constructed and reused

Contains color groups for each widget state

Parallel group of animations

Pause for QSequentialAnimationGroup

Loads a PDF document and renders pages from it

Defines a link between a region on a page (such as a hyperlink or a search result) and a destination (page, location on the page, and zoom level at which to view it)

Encapsulates the rendering of pages of a PDF document

Defines a range of text that has been selected on one page in a PDF document, and its geometric boundaries

Class to generate PDFs that can be used as a paint device

Presents a series of categorized data as a percentage of each category

Paint device that records and replays QPainter commands

Presents data in pie charts

Describes a pinch gesture made by the user

Off-screen image representation that can be used as a paint device

Implements a plain text layout for QTextDocument

Used to notify about native platform surface events

Defines a point in the plane using integer precision

Template class that provides guarded pointers to QObject

Describes a device from which mouse, touch or tablet events originate

Presents data in polar charts

List of points using floating point precision

Holds readings from the pressure sensor

Dialog for specifying the printer's configuration

Dialog for previewing and configuring page layouts for printer output

Paint device that paints on a printer

Used to start external programs and to communicate with them

Horizontal or vertical progress bar

Way to store computation results to be accessed by QFuture

Animates Qt properties

Controls the lifecycle of change callback installed on a QProperty

Controls the lifecycle of change callback installed on a QProperty

Represents one reading from the proximity sensor

Convenience class that simplifies dynamically overriding QStyle elements

Allows you to control QML file loading

Encapsulates a QML component definition

Environment for instantiating QML components

Encapsulates a QML error

A class for applying a QFileSelector to QML file loading

Instances drive the progress of QQmlIncubators

Allows applications to expose list-like properties of QObject-derived classes to QML

Creates QNetworkAccessManager instances for a QML engine

Abstracts accessing properties on objects created from QML

Interface for property value sources such as animations and bindings

Represents a quaternion consisting of a vector and scalar

Helper class for selecting correct surface format

Base class for defining instance tables

Base class for defining custom texture data

Convenience class for integrating OpenGL rendering using a framebuffer object (FBO) with Qt Quick

Opaque container for native graphics objects representing graphics devices or contexts

Interface for asynchronous image loading in QQuickAsyncImageProvider

Contains the result from QQuickItem::grabToImage()

Mechanism for rendering the Qt Quick scenegraph onto an offscreen render target in a fully application-controlled manner

Allows configuring the application style

Interface for loading custom textures from QML

Web engine profile shared by multiple pages

The window for displaying a graphical QML scene

Radio button with a text label

Allows one to obtain 64-bit random values from a high-quality, seed-less Random Number Generator

Convenience class for using QPainter on a QWindow

Convenience class that simplifies locking and unlocking read-write locks for read access

Defines a rectangle in the plane using integer precision

Access serialization between threads

Specifies a clip region for a painter

The results of a matching a QRegularExpression against a string

Used to check a string against a regular expression

A dynamically instantiated Replica

Base functionality common to Host and RegistryHost classes

Encapsulates the result of an asynchronous method call

A templated version of QRemoteObjectPendingCall

A (Host/Registry) node on a Qt Remote Objects network

Contains event parameters for resize events

Struct contains a 64-bit RGB color

Shared base for calendars based on the ancient Roman calendar

Represents one reading from the rotation sensor

Rectangle or line that can indicate a selection or a boundary

Serves as a baseclass for geometry based nodes

Serves as a baseclass for dynamically changing textures, such as content that is rendered to FBO's

Low-level storage for graphics primitives in the Qt Quick Scene Graph

Provided for convenience to easily draw textured content using the QML scene graph

Represents a graphics API independent shader program

The base class for all nodes in the scene graph

Convenient way of rendering textured geometry in the scene graph

Represents a set of custom rendering commands targeting the graphics API that is in use by the scenegraph

Convenience class for drawing solid filled rectangles using scenegraph

The base class for textures used in the scene graph

Encapsulates texture based entities in QML

Convenient way of rendering per-vertex colored geometry in the scene graph

Represents a data series in a 3D scatter graph

The data proxy for 3D scatter graphs

Provides a scope guard for calling a function at the end of a scope

Stores a pointer to a dynamically allocated object, and deletes it upon destruction

Used to query screen properties

Vertical or horizontal scroll bar

Sent in preparation of scrolling

Stores the settings for a QScroller

SCTP socket

C++ data model for a Qt SCXML state machine

Creates SCXML service instances from documents loaded at runtime

Event for a Qt SCXML state machine

Represents a unit of executable content

Represents a service invocation

The base class for services called from state machines

The null data model for a Qt SCXML stateMachine

Creates SCXML service instances from precompiled documents

General counting semaphore

Represents a single hardware sensor

Instantiates instances of QSensorBackend

Efficient callback facility for asynchronous notifications of sensor changes

The pure virtual interface to sensor plugins

Sequential group of animations

Provides functions to access serial ports

Access to the session manager

Java-style const iterator for QSet

Base class for shared data objects

Access to a shared memory segment

Used to create keyboard shortcuts

Event that is sent when a widget is shown

Bundles signals from identifiable senders

Transition based on a Qt signal

Defines the size of a two-dimensional object using integer point precision

Resize handle for resizing top-level windows

Vertical or horizontal slider

Support for sorting and filtering data passed between another model and a view

Blank space in a layout

Spin box widget

Presents data as spline charts

Handle functionality for the splitter

Abstract base class for accessing specific SQL databases

The base class for SQL driver factories

SQL database error information

Functions to manipulate and describe database indexes

Read-only data model for SQL result sets

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

API for accessing the extensions of an X509 certificate

Holds the configuration and state of an SSL connection

Represents an elliptic curve for use by elliptic-curve cipher algorithms

Interface for private and public keys

Implements an encrypted, secure TCP server over TLS

Template class that provides a stack

Stack of widgets where only one widget is visible at a time

Item for use with the QStandardItemModel class

Generic model for storing custom data

General-purpose state for QStateMachine

Compile-time version of QByteArrayMatcher

Enables optimized drawing of text when the text and its layout is updated rarely

Event that is used to show messages in a status bar

Unicode character string

State-based decoder for text

List of strings

Holds a sequence of characters that can be quickly matched in a Unicode string

Splits strings into tokens along given separators

Abstract base class that encapsulates the look and feel of a GUI

Style hints that return more than basic data types

Style hints that return a QVariant

Stores the parameters used by QStyle functions

Used to describe the parameter for drawing a combobox

Used to describe the parameters for drawing a dock widget

Used to describe the parameters for drawing a frame

Describes the parameters for drawing a group box

Used to describe the parameters for drawing a header

Used to describe the parameters necessary for drawing a progress bar

Used to describe the parameter for drawing a size grip

Used to describe the parameters necessary for drawing a spin box

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 a title bar

Used to describe the parameters needed for drawing a tool box

Used to describe the parameters used to draw an item in a view widget

Abstract base for custom QStyle plugins

Used when registering fonts with the internal Qt fontdatabase

Represents a data series in a 3D surface graph

The data proxy for a 3D surface graph

Paint device that is used to create SVG drawings

Widget that is used to display the contents of Scalable Vector Graphics (SVG) files

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

General counting system semaphore

Tab bar, e.g. for use in tabbed dialogs

Default model/view implementation of a table view

Item for use with the QTableWidget class

Contains parameters that describe a Tablet event

Describes a tap-and-hold (aka LongTap) gesture made by the user

TCP-based server

Creates a unique directory for temporary use

Used to simulate a sequence of touch events

Container for text fragments in a QTextDocument

Container for text blocks within a QTextDocument

Way of finding Unicode text boundaries in a string

Formatting information for characters in a QTextDocument

Offers an API to access and modify QTextDocuments

Holds formatted text

Format-independent interface for writing a QTextDocument to files or other devices

State-based encoder

Holds a piece of text in a QTextDocument with a single QTextCharFormat

Formatting information for frames 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

Formatting information for lists in a QTextDocument

Allows drawing of custom text objects in QTextDocuments

Convenient interface for reading and writing text

Represents the properties of a cell in a QTextTable

Formatting information for tables in a QTextDocument

Platform-independent way to manage threads

Per-thread data storage

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

Widget for editing times based on the QDateTimeEdit widget

Converts between UTC and local time in a specific time zone

Contains parameters that describe a timer event

Column of tabbed widget items

Tool tips (balloon help) for any widget

Contains parameters that describe a touch event

Internationalization support for text output

Default model/view implementation of a tree view

Item for use with the QTreeWidget convenience class

Contains a lightweight representation of a version number with two 8-bit segments, major and minor, either of which can be unknown

Enables standalone applications to dynamically create user interfaces at run-time using the information stored in UI files or specified in plugin paths

Group of QUndoStack objects

Displays the contents of a QUndoStack

Uniform interface over bindable properties like QProperty\ and QObjectBindableProperty of any type T

Way to manipulate a key-value pairs in a URL's query

Stores a Universally Unique Identifier (UUID)

Lines up widgets vertically

Vertical model mapper for a candlestick series

Vertical model mapper for line, spline, and scatter series

Manipulates an axis of a graph

Adds values to a chart's axes

Acts like a union for the most common Qt data types

Emulated const pointer to QVariant based on a pointer

Acts as a non-const reference to a QVariant

Represents a vector or vertex in 2D space

Represents a vector or vertex in 4D space

Represents a frame of video data

Represents a generic sink for video data

Base class for input methods

Dictionary management for application-defined dictionaries

InputEngine class provides an input engine that supports C++ and QML integration

List model for selection lists

Represents a particular voice

Represents information about a Vulkan extension

A specialized QList for QVulkanLayer and QVulkanExtension

Represents information about a Vulkan layer

Used to implement the application-specific rendering logic for a QVulkanWindow

Holds the reference to a surface buffer

Manages the Wayland display server

Convenience class for subclassing QWaylandCompositorExtension

Extension for embedded-style user interfaces

Represents a keyboard device

Represents a displayable area managed by the compositor

Represents a pointer device

Provides access to input methods in the compositor

Provides support for shell surface integration with QtQuick

Container for a wl_resource