Represents a unit of executable content

Represents a foreach construct

Represents a service invocation

Represents a parameter to a service invocation

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

Base class for audio backends

Base class for audio backends

Abstract parent class for all bar series classes

Base class for all data visualization data proxies

Interface for extension factories in Qt Designer

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

Common base for all path items

The abstract interface for item model classes

The basic functionality for item view classes

Abstract model that can be subclassed to create one-dimensional list models

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

The base of all implementations of OAuth authentication methods

Handles replies to OAuth authentication requests

Abstraction for planar video data

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

Scrolling area with on-demand scroll bars

A skeleton contains the joints for a skinned mesh

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

Encapsulates the necessary information to create an OpenGL texture image

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

Represents a filter that is applied to the video frames received by a VideoOutput type

Abstract base class for modeling non-XML data to look like XML for QXmlQuery

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

Abstract user interface action that can be inserted into widgets

Groups actions together

Specify alpha reference test

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

Holds readings of the ambient temperature

Interface used for callbacks from onActivityResult() in the main Android activity

Manages the GUI application's control flow and main settings

Presents data in area charts

Responsible for handling all the QAbstractAspect subclasses that have been registered with the scene

Iterable interface for an associative container in a QVariant

Platform-independent atomic operations on integers

Defines an attribute and how data should be read from a QBuffer

Allows decoding audio

Interface to query audio devices and their functionality

Access to the settings of a media service that performs audio encoding

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

Control over the audio role of a media object

Authentication object

Abstract class that provides an API to initialize and access a COM object

Defines a factory for the creation of COM components

Wrapper around script code

Bridge between application objects and script code

QWidget that wraps an ActiveX control

Base class for all Qt3D backend nodes

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

Timer events for objects

Monochrome (1-bit depth) pixmaps

Encapsulates blending information: specifies how the incoming values (what's going to be drawn) are going to affect the existing values (what is already drawn)

Assigns an address to the Bluetooth device

Stores information about the Bluetooth device

Enables access to the local Bluetooth device

Enables you to query for Bluetooth services

Enables connection to a Bluetooth device running a bluetooth server

Stores the response for a data transfer request

Generates a UUID for each Bluetooth service

Legend marker for a box plot series

Represents one item in a box-and-whiskers chart

Provides a data store for raw data to later be used as vertices or uniforms

Exchanges buffer data between GPU and CPU

Container to organize groups of button widgets

List of byte arrays

Template class that provides a cache

Defines a view point through which the scene will be rendered

Control for setting the capture buffer format

Abstract base class for classes that control still cameras or video cameras

Allows controlling camera exposure parameters

Allows controlling a camera's flash

Supplies control for focusing related camera parameters

Used for the recording of media content

Interface for image processing related camera settings

General information about camera devices

Qt3DRender::QCameraLens specifies the projection matrix that will be used to define a Camera for a 3D scene

Class to allow for selection of camera to be used

Abstract class for controlling camera viewfinder parameters

Supplies control for optical and digital camera zoom

The interface class for CAN bus

Factory class used as the plugin interface for CAN bus plugins

Legend marker for a candlestick series

Presents data as candlesticks

Manipulates an axis of a graph

Manages the graphical representation of the chart's series, legends, and axes

Checkbox with a text label

Class to clear buffers

Enables an additional OpenGL clipping plane that can be in shaders using gl_ClipDistance

Contains parameters that describe a close event

Inline class containing miscellaneous functionality for NSWindow and NSView window specific functionality

Can be used to speed up string collation

Dialog widget for specifying colors

Maps device independent QColors to device dependent pixel values

Combined button and popup list

Means for handling the command line options

Encapsulates the common Look and Feel of a GUI

Convenience wrapper around QSensorFilter

Completions based on an item model

Used to notify when a component is added to an entity

QComponent to issue work for the compute shader on GPU

Contains parameters that describe a context menu event

Event loop for Qt applications without UI

Specifies whether front or back face culling is enabled

Adds a custom item to a graph

Adds a volume rendered object 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

Tests the fragment shader's depth value against the depth of a sample being written to

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

Encapsulate a Directional Light object in a Qt 3D scene

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

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

Used to notify when a dynamic property value is updated

Easing curves for controlling animation

Inline class containing platform-specific functionality for the eglfs platform plugin that is typically used on systems running Embedded Linux or Android

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

Qt3DCore::QEntity is a Qt3DCore::QNode subclass that can aggregate several Qt3DCore::QComponent instances that will specify its behavior

Error message display dialog

Means of entering and leaving an event loop

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

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

Defines front and back facing polygons

Represents the result of an asynchronous computation

Convenience class that simplifies QFuture synchronization

A class encapsulating a GLXContext and related native handles

Provides support for keyboard events triggered by gamepads

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

Support for geocoding operations

Defines a geographical position on the surface of the Earth

Represents the information relevant to the point at which two QGeoRouteSegments meet

Defines a geographic polygon

Abstract base class for the distribution of positional updates

Defines a rectangular geographic area

Manages an operation started by an instance of QGeoRoutingManager

Represents a segment of a route

Interface and convenience methods to implementers of QGeoServiceProvider plugins who want to provide access to geographic routing information

Abstract base class for the distribution of satellite information updates

Factory class used as the plugin interface for services related to geographical information

Encapsulates geometry

Encapsulates geometry rendering

The description of triggered gestures

Used to implement a global static object

Used in combination with QBrush to specify gradient fills

Layout where one can anchor widgets together in Graphics View

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

The base class for all widget items in a QGraphicsScene

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

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

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

Means of returning to a previously active substate

Holds readings from the holster sensor

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)

Holds a body part to be used inside a HTTP multipart MIME message

Holds readings from the humidity sensor

The base interface class of all I/O devices in Qt

Holds readings from the IR proximity sensor

Scalable icons in different modes and states

Abstract base class for QIcon renderers

Proxies its source model unmodified

Access to the settings of a media service that performs image encoding

Defines the common image I/O interface for all image formats in Qt

Format independent interface for reading images from files or other devices

A product registered in the store

Contains information about a transaction in the external app store

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

Acts as a container for Qt/JavaScript data types

Used to transforms parts of skinned meshes

Way to read and write JSON documents

Used to report errors during JSON parsing

Transition for key events

Allows to input a QKeySequence

Displays a number with LCD-like digits

Text or image display

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

Controls layers drawn in a frame graph branch

Abstract item that a QLayout manipulates

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

Simple spherical volume, defined by its center and radius

Loads shared libraries at runtime

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

Represents one reading from the light sensor

Two-dimensional vector using integer precision

Two-dimensional vector using floating point precision

Specifies the width of rasterized lines

Template class that provides linked lists

Template class that provides lists

List or icon view onto a model

Item for use with the QListWidget item view class

Local socket

Locking between processes using a file

Adds a logarithmic scale to a chart's axis

Represents the data to be broadcast during Bluetooth Low Energy advertising

Stores information about a Bluetooth Low Energy service characteristic

Used when requesting or reporting an update of the parameters of a Bluetooth LE connection

Stores information about the Bluetooth Low Energy descriptor

Represents an individual service on a Bluetooth Low Energy Device

Widget for macOS that can be used to wrap arbitrary Cocoa views (i.e., NSView subclasses) and insert them into Qt hierarchies

Converts between a MIME type and a Uniform Type Identifier (UTI) format

Item for QMacToolBar

Convenience wrapper around QSensorFilter

Main application window

Java-style const iterator for QMap and QMultiMap

Defines the four margins of a rectangle

Provides an abstract class that should be the base of all material component classes in a scene

Area in which MDI windows are displayed

Allows control over probing audio data in media objects

The base class for objects extending media objects functionality

Access to the resources relating to a media content

Access to the gapless playback related control of a QMediaService

Common base for multimedia objects

Access to the media playing functionality of a QMediaService

Used for the recording of media content

Description of a media resource

Interface provides camera-specific information about devices supported by a camera service plug-in

Interface identifies features supported by a media service plug-in

Interface identifies the devices supported by a media service plug-in

Media stream selection control

Represents a set of zero or more disjoint time intervals

Class to emplace a memory barrier

Horizontal menu bar

Way to generate hash-based message authentication codes

Additional information about a log message

Additional information about a class

Write access to the meta-data of a QMediaService's media

Meta-data about a member function

Meta-data about a property

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 a Modbus server that uses a TCP server for its communication with the Modbus client

Transition for mouse events

Convenience class for playing movies with QImageReader

Convenience QMap subclass that provides multi-valued maps

Java-style non-const iterator for QHash and QMultiHash

Java-style non-const iterator for QList and QQueue

Java-style non-const iterator for QSet

Access serialization between threads

Contains parameters that describe a gesture event

NFC NDEF message

NFC RTD-Text

NFC NDEF record

Manages all interactions related to sharing files and data over NFC

Interface for communicating with a target device

Stores one IP address supported by a network interface, along with its associated netmask and broadcast address

Abstraction of one or more access point configurations

Holds one network cookie

The data and metadata of a UDP datagram

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

Control over the system's access points and enables session management for cases when multiple clients access the same access point

Disable depth write

The base class of all Qt3D node classes used to build a Qt3D scene

Used to notify when a node is created

Used to notify when a node is destroyed

Implements OAuth 1 signature methods

The base class of all Qt objects

Instantiates a component that can be used to interact with a QEntity by a process known as picking

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

Represents the version and if applicable the profile of an OpenGL context

Widget for rendering OpenGL graphics

Information about the operating system version

Represents one reading from the orientation sensor

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

Contains event parameters for paint events

Performs low-level painting on widgets and other paint devices

Used to generate fillable outlines for a given painter path

Contains color groups for each widget state

Parallel group of animations

Pause for QSequentialAnimationGroup

Defines how a QPainter should draw lines and outlines of shapes

Used to locate data in a data model

Holds information when an object is picked

Holds information when a segment of a point cloud is picked

Specifies how entity picking is handled

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

Represents an icon

Represents a reference to an image

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

Manages a place search operation started by an instance of QPlaceManager

The base class for search results

Represents a supplier of a place or content associated with a place

Implements a plain text layout for QTextDocument

Used to notify about native platform surface events

Defines a point in the plane using integer precision

Encapsulate a Point Light object in a Qt 3D scene

Template class that provides guarded pointers to QObject

Presents data in polar charts

Vector of points using floating point 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

Used to notify when a node is added to a property

Used to notify when a property value is updated

Used to notify when a value is added to a property

Used to notify when a value is added to a property

Select entities which are within a distance threshold of a target entity

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

Evaluates JavaScript in a QML context

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

Implements the NdefRecord type in QML

Updates on the QML parser state

Allows you to set key-value pairs that can be used in QML bindings

Encapsulates a script and its context

Generic container that provides a queue

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

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

Access to the QTextDocument of QQuickTextEdit

Window for displaying a Qt Quick user interface

Enables the injection of scripts in the JavaScript engine

The window for displaying a graphical QML scene

Radio button with a text label

Access to the RDS functionality of the radio in the QMediaService

Access to the radio tuning functionality of a QMediaService

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

Qt3DRender::QRayCaster is used to perform ray casting tests in 3d world coordinates

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

Defines a rectangle in the plane using integer precision

Pattern matching using regular expressions

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

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

Frame graph node for render capture

Encapsulates a Render Pass

Holds settings related to rendering process and host the active FrameGraph

FrameGraph node offers a way of specifying a set of QRenderState objects to be applied during the execution of a framegraph branch

Encapsulates a target (usually a frame buffer object) which the renderer can render into

Provides a way of specifying a render target

Interface for reading directly from resources

Convenience wrapper around QSensorFilter

Convenience wrapper around QSensor

The base class for all runnable objects

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

Convenient way of rendering solid colored geometry in the scene graph

Used for all rendered content in the scene graph

Encapsulates rendering state for a shader program

Used as a unique type token in combination with QSGMaterial

Used to change opacity of nodes

Convenience class for drawing solid filled rectangles using scenegraph

An interface providing access to some of the graphics API specific internals of the scenegraph

Convenient way of building custom OpenGL-based materials for the scene graph

Convenient way of rendering textured geometry in the scene graph

Implements transformations in the scene graph

Interface for safely writing to files

Container for resolved data to be added to scatter graphs

Presents data in scatter charts

Provides the facility to load an existing Scene

Stores a pointer to a dynamically allocated array of objects, and deletes it upon destruction

Resets a variable to its previous value on destruction

Performe ray casting test based on screen coordinates

Iterator interface for custom Qt Script objects

Additional information about a QScriptContext

Interface to report events pertaining to QScriptEngine execution

Abstract base for custom QScript extension plugins

Acts as a handle to "interned" strings in a QScriptEngine

Acts as a container for the Qt Script data types

Access to the Qt Script environment from Qt C++ member functions

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

Describes the errors returned by the Qt SCXML state machine when parsing an SCXML file

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

Enables seamless cubemap texture filtering

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

Sensor implementation

The pure virtual interface to sensor plugins

Represents one or more sensor gesture recognizers

The pure virtual interface to sensor gesture 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

Encapsulates a Shader Program

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

Enables introspection of signal emission

Implementation of QAbstractXmlNodeModel sufficient for many common cases

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

Layout attribute describing horizontal and vertical resizing policy

Used to load a skeleton of joints from file

Support for monitoring activity on a file descriptor

Provides storage for the sort types to be used

Way to play low latency sound effects

Blank space in a layout

Splash screen that can be shown during application startup

Implements a splitter widget

Encapsulate a Spot Light object in a Qt 3D scene

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

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

The base class for all static PropertyValueAdded QSceneChange events

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

Specifies stencil operation

Specifies arguments for the stecil test

Provides information about currently mounted storage and drives

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

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 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

Convenience wrapper around QSensorFilter

Represents one reading from the tap sensor

TCP-based server

Encapsulates a Technique

Creates a unique directory for temporary use

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