Annotated Class List

Methods for rendering 3D bar graphs

Basic wheel mouse based input handler

Simple base class for all the objects in a 3D scene

Description of the 3D scene being visualized

Visual style for graphs

Window and render loop for graphs

Base class for all data series

Base class used for specialized axis classes

The abstract base class of button widgets, providing functionality common to buttons

Interface to manage Qt's event queue

Interface for extension managers in Qt Designer

Default implementation for classes that create user interfaces at run-time

Interface that represents common gRPC channel functionality

QAbstractGrpcClient is an abstract storage class used by authentication parameters

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

Base class for proxy item models that can do sorting, filtering or other data processing tasks

Base class for all Qt Chart series

The base functionality common to all socket types

The base class of states of a QStateMachine

Abstract base class used to implement custom layouts for QTextDocuments

Convenience wrapper around QSensor

Reports on linear acceleration along the X, Y and Z axes

Implements support for invocable actions in the interface

The base class for accessibility notifications

Implements parts of the QAccessibleInterface for QObjects

Implements support for selection handling

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

Access Bluetooth peripherals

Enables you to query for Bluetooth services

Enables connection to a Bluetooth device running a bluetooth server

Lines up child widgets horizontally or vertically

Presents data in box-and-whiskers charts

Defines the fill pattern of shapes drawn by QPainter

Container to organize groups of button widgets

List of byte arrays

View on an array of bytes with a read-only subset of the QByteArray API

Describes calendar systems

Monthly based calendar widget allowing the user to select a date

General information about camera devices

Access the camera for taking pictures or videos

The interface class for CAN bus

Factory class used as the plugin interface for CAN bus plugins

Can be used to parse DBC files

Describes the rules to process a CAN message and represent it in an application-defined format

Describes the rules for accessing a unique identifier in a QCanBusFrame

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

Access the user's contacts

Template class that provides a contiguous cache

Way to generate cryptographic hashes

Adds a custom item to a graph

Adds a volume rendered object to a graph

The base class for all D-Bus interfaces in the Qt D-Bus binding, allowing access to remote interfaces

Represents a connection to the D-Bus bus daemon

Allows slots to determine the D-Bus context of the calls

Proxy for interfaces on remote objects

Enables the programmer to identify the OBJECT_PATH type provided by the D-Bus typesystem

Convenient way for waiting for asynchronous replies

Stores the reply for a method call to a remote object

Allows the user to watch for a bus service change

Holds one Unix file descriptor

Used to handle several DBus paths with one class

Mapping between a section of a data model to widgets

Widget for editing dates based on the QDateTimeEdit widget

Adds dates and times to a chart's axis

Marks a deadline in the future

Convenience class for custom QDebug operators

Allows you to add pages to a custom multi-page container in Qt Designer's workspace

Enables Qt Designer to access and construct custom widgets

Allows you to access Qt Designer's various components

Allows you to query and manipulate form windows appearing in Qt Designer's workspace

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 query and manipulate the current state of Qt Designer's property editor

Allows you to add custom menu entries to Qt Designer's task menu

Methods for accessing common desktop services

The base class of dialog windows

Access to directory structures and their contents

Stores information about a domain name record

Represents a DNS lookup

Stores information about a DNS SRV record

Widget that can be docked inside a QMainWindow or floated as a top-level window on the desktop

Represents an XML CDATA section

Represents an XML comment

Tree of QDomNodes which is not usually a complete QDomDocument

Represents one element in the DOM tree

Represents an XML entity reference

Contains a collection of nodes that can be accessed by name

List of QDomNode objects

Represents an XML processing instruction

Spin box widget that takes doubles

Support for MIME-based drag and drop data transfer

Event that is sent to a widget when a drag and drop action leaves it

Event which is sent when a drag and drop action is completed

This class implements server-side DTLS cookie generation and verification

Easing curves for controlling animation

A base class that allows obtaining a QSharedPointer for an object already managed by a shared pointer

Error message display dialog

Means of entering and leaving an event loop

Information about a point in a QPointerEvent

Base class for exceptions that can be transferred across threads

Contains event parameters for expose events

Extension management facilities for Qt Designer

Interface for reading from and writing to open files

File icons for the QFileSystemModel class

Event that will be sent when there is a request to open a file or a URL

Data model for the local filesystem

Final state

Type-safe way of storing OR-combinations of enum values

Focus frame which can be outside of a widget's normal paintable area

Combobox that lets the user select a font family

Dialog widget for selecting a font

Font metrics information

Used to dynamically construct user interfaces from UI files at run-time

The base class of widgets that can have a frame

Java-style const iterator for QFuture

Allows monitoring a QFuture using signals and slots

Template class that represents a NxM transformation matrix with N columns and M rows

Creates plugin drivers

Represents an address of a QGeoLocation

Enables the detection of proximity changes for a specified set of coordinates

Manages an operation started by an instance of QGeoCodingManager

Interface and convenience methods to implementers of QGeoServiceProvider plugins who want to provide support for geocoding operations

Represents basic information about a location

Defines a geographic path

Contains information gathered on a global position, direction and velocity at a particular point in time

Factory class used as the plugin interface for external providers of positioning data

Represents a route between two points

Represents the parameters and restrictions which define a request for routing information

Support for geographic routing operations

Contains basic information about a satellite

Aggregates access to services which provide geographical information

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

Contains data for asynchronous call of gRPC client API

The base class for gRPC channel credentials

HTTP/2 implementation of QAbstractGrpcChannel interface

Dummy implementation of QGrpcChannelCredentials

SSL credentials for channel

Implements logic to handle stream communication in the Grpc channel

Manages the GUI application's control flow and main settings

Convenience wrapper around QSensorFilter

Horizontal model mapper for bar series

Horizontal model mapper for box plot series

Horizontal model mapper for pie series

Template class that provides a hash-table-based dictionary

Base proxy class for Q3DSurface

Model that supplies content to views

Access to contents and indices of the help engine

Event that is used to request helpful information about a particular point in a widget

Filtered view of the help contents

Model that supplies index keywords to views

Struct provides the data associated with a help link

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

Means of returning to a previously active substate

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

IP address

Contains parameters that describe a mouse event

Controls HTTP/1 parameters and settings

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

Optimized search for substring in Latin-1 text

The base class of geometry managers

Displays the legend of a chart

Loads shared libraries at runtime

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

One-line text editor

Presents data in line charts

Template class that provides linked lists

Template class that provides a dynamic array

List or icon view onto a model

Item for use with the QListWidget item view class

Local socket

Access the user's location

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

Milanković calendar system implementation

Maintains a database of MIME types

The interface to send Modbus requests

The base class for Modbus classes, QModbusServer and QModbusClient

Container class containing the function and error code inside a Modbus ADU

Contains the data for a request sent with a QModbusClient derived class

Container class containing the function code and payload that is stored inside a Modbus ADU

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

Holds a role and the data associated to that role

Contains parameters that describe a mouse event

Contains event parameters for move events

Represents configuration options during the authentication process

Represents configuration options a QMqttClient can pass to the server when invoking QMqttClient::connectToHost()

Information about a message received from a message broker based on a subscription

Represents configuration options for sending or receiving a message

Represents the string pair data type of the MQTT 5.0 standard

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

Represents a MQTT topic name

Represents a list of QMqttStringPair values which can be passed to the server

Template class that provides an associative array with multiple equivalent keys

Java-style non-const iterator for QHash and QMultiHash

Java-style non-const iterator for QList, QQueue and QStack

Java-style non-const iterator for QMultiMap

Access serialization between threads

Contains parameters that describe a gesture event

Native interface to a offscreen surface on Android

Native interface to an EGL context

Provides access to and enables adopting Direct3D 11 texture objects

Provides access to and enables adopting OpenGL texture objects

Native interface to a WGL context on Windows

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)

Navigation history within a PDF document

A widget for selecting a PDF page

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

Used to locate data in a data model

Legend marker for a pie series

Represents a single slice in a pie series

Class for describing different pixel layouts in graphics buffers

Application-wide cache for pixmaps

Represents generic attribute information about a place

Represents a contact detail such as a phone number or website url

Manages a content retrieval operation started by an instance of QPlaceManager

Manages a place details fetch operation started by an instance of QPlaceManager

Manages operations which return an identifier such as saving and removal operations of places and categories

Interface for implementers of QGeoServiceProvider plugins who want to provide access to place functionality

Used to find places from one manager that match those from another. It represents a set of request parameters

Holds rating information about a place

Represents a search result containing a place

Represents the set of parameters for a search request

Manages a search suggestion operation started by an instance of QPlaceManager

Represents an individual user

Widget that is used to edit and display plain text

Loads a plugin at run-time

Defines a point in the plane using floating point precision

A base class for pointer events

Identifies a unique object, such as a tagged token or stylus, which is used with a pointing device

List of points using integer precision

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

Defines an interface for how QPrinter interacts with a given printing subsystem

Widget for previewing page layouts for printer output

Gives access to information about existing printers

Holds the environment variables that can be passed to a program

Feedback on the progress of a slow operation

Template class that enables automatic property bindings

Helper class for properties with automatic property bindings

Base class for all protobuf messages

Interface that represents basic functions for serialization/deserialization

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

Abstract base for custom QML extension plugins with custom type registration functions

Used to register image providers in the QML engine

Allows QML objects to be created asynchronously

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

Way to propagate attached properties

Controls lower level graphics settings for the QQuickWindow

Interface for supporting pixmaps and threaded image requests in QML

The most basic of all visual items in Qt Quick

Way to use the QPainter API in the QML Scene Graph

Opaque container for native graphics resources specifying a render target, and associated metadata

Access to the QTextDocument of QQuickTextEdit

Window for displaying a Qt Quick user interface

Widget for displaying a Qt Quick user interface

Used in combination with QBrush to specify a radial gradient brush

Allows one to obtain random values from a high-quality 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

Scrolling view onto another widget

Sent when scrolling

Enables kinetic scrolling for any scrolling widget or graphics item

SCTP-based server

Compiler for SCXML files

The data model base class 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 foreach construct

Represents a parameter to a service invocation

Creates invokable service instances

Interface to the state machines created from SCXML files

Used by compiled state machines

Exception-safe deferral of a QSemaphore::release() call

Sensor implementation

The pure virtual interface to sensor plugins

Handles registration and creation of sensor backends

Holds the readings from the sensor

Iterable interface for a container in a QVariant

Provides information about existing serial ports

Template class that provides a hash-table-based set

Persistent platform-independent application settings

Represents a pointer to an implicitly shared object

Holds a strong reference to a shared pointer

Event which is generated when the user presses a key combination

Exception-safe wrapper around QObject::blockSignals()

Enables introspection of signal emission

A base class for pointer events containing a single point, such as mouse events

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

Layout attribute describing horizontal and vertical resizing policy

Support for monitoring activity on a file descriptor

Way to play low latency sound effects

A sound object in 3D space

Splash screen that can be shown during application startup

Implements a splitter widget

Handles a connection to a database

Template class that provides a SQL driver factory for a specific driver type

Abstract base for custom QSqlDriver plugins

Manipulates the fields in SQL database tables and views

Means of executing and manipulating SQL statements

Encapsulates a database record

Delegate that is used to display and edit data from a QSqlRelationalTableModel

Abstract interface for accessing data from specific SQL databases

Convenient API for an X509 certificate

Represents an SSL cryptographic cipher

Interface for Diffie-Hellman parameters for servers

SSL error

Authentication data for pre shared keys (PSK) ciphersuites

SSL encrypted socket for both clients and servers

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

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

The possibility to register widgets without having to subclass QItemEditorCreatorBase

Methods for accessing standard paths

Hierarchical finite state machine

Struct containing a reference to a static plugin instance together with its meta data

Horizontal bar suitable for presenting status information

Provides information about currently mounted storage and drives

Base class for encoding and decoding text

State-based encoder for text

Model that supplies strings to views

Thin wrapper around QString substrings

Unified view on UTF-16 strings with a read-only subset of the QString API

Creates QStyle objects

Style hints that return a QRegion

Contains platform specific hints and settings

Used to describe the parameters for drawing buttons

Used to hold parameters that are common to all complex controls

Used to describe the parameters for drawing a focus rectangle with QStyle

Used to describe the parameters needed to draw a QGraphicsItem

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 needed for drawing a rubber band

Used to describe the parameters needed for drawing a slider

Used to describe the parameters for drawing a tab bar

Used to describe the parameters for drawing the frame around a tab widget

Used to describe the parameters for drawing a toolbar

Used to describe the parameters for drawing a tool button

Convenience class for drawing QStyle elements inside a widget

Display and editing facilities for data items from a model

Abstraction of renderable surfaces in Qt

Container for resolved data to be added to surface graphs

Represents the format of a QSurface

Used to draw the contents of SVG files onto paint devices

Describes a swipe gesture made by the user

Information about the system

Icon for an application in the system tray

Stack of tabbed widgets

Item-based table view with a default model

Way to interact with selection in a model without using model indexes and a selection model

Template class that wraps an iterator and exposes standard iterator traits

Describes a tap gesture made by the user

TCP socket

I/O device that operates on temporary files

List of GUI events

Formatting information for blocks of text in a QTextDocument

Used to associate custom data with blocks of text

Rich text browser with hypertext navigation

Conversions between text encodings

State-based decoder

Represents a piece of formatted text from a QTextDocument

Widget that is used to edit and display both plain and rich text

Formatting information for a QTextDocument

Represents a frame in a QTextDocument

Formatting information for images in a QTextDocument

All the information required to draw text in a custom paint engine

Encapsulates the different types of length used in a QTextDocument

Decorated list of items 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

Formatting information for table cells in a QTextDocument

Convenient access to text-to-speech engines

Manages a collection of QThreads

The rules used to draw a pixmap or image split into nine segments

Holds readings from the tilt sensor

Clock time functions

Timeline for controlling animations

Repetitive and single-shot timers

Movable panel that contains a set of controls

Quick-access button to commands or options, usually used inside a QToolBar

Basic touch display based input handler

Specifies 2D transformations of a coordinate system

This proxy transposes the source model

Tree view that uses a predefined tree model

Way to iterate over the items in a QTreeWidget instance