Class Index — PyQt Documentation v6.9.0 (original) (raw)
3 | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y
3
Methods for rendering 3D bar graphs
TODO
Representation of a camera in 3D space
TODO
Basic wheel mouse based input handler
Representation of a light source in 3D space
Simple base class for all the objects in a 3D scene
Methods for rendering 3D scatter graphs
TODO
Q3DScene (PyQt6.QtDataVisualization)
Description of the 3D scene being visualized
Q3DScene (PyQt6.QtGraphs)
Description of the 3D scene being visualized
Methods for rendering 3D surface plots
TODO
Visual style for graphs
TODO
A
QAbstract3DAxis (PyQt6.QtDataVisualization)
Base class for the axes of a graph
QAbstract3DAxis (PyQt6.QtGraphs)
Base class for the axes of a 3D graph
Window and render loop for graphs
Base class for implementations of input handlers
QAbstract3DSeries (PyQt6.QtDataVisualization)
Base class for all data series
QAbstract3DSeries (PyQt6.QtGraphs)
Base class for all 3D data series
The base class for the Action Input and all Aggregate Action Inputs
QAbstractAnimation (PyQt6.Qt3DAnimation)
An abstract base class for Qt3D animations
QAbstractAnimation (PyQt6.QtCore)
The base of all animations
The base class for types providing key frame animation data
The base class for aspects that provide a vertical slice of behavior
QAbstractAxis (PyQt6.QtCharts)
Base class used for specialized axis classes
QAbstractAxis (PyQt6.QtGraphs)
Base class used for specialized axis classes
QAbstractActionInput is the base class for all Axis Input
Abstract parent class for all bar series classes
The abstract base class of button widgets, providing functionality common to buttons
Basic functionality for camera controllers
TODO
The base class for types providing animation playback capabilities
The base class for types used to construct animation blend trees
QAbstractDataProxy (PyQt6.QtDataVisualization)
Base class for all data visualization data proxies
QAbstractDataProxy (PyQt6.QtGraphs)
Base class for all 3D graph proxies
Interface to manage Qt's event queue
Interface for extension factories in Qt Widgets Designer
Interface for extension managers in Qt Widgets Designer
File icons for the QFileSystemModel class
Default implementation for classes that create user interfaces at run-time
Abstract base class for all functors
Common base for all path items
Used to display and edit data items from a model
The abstract interface for item model classes
Serves as a convenience class for Replicas of Sources based on QAbstractItemModel
Helps testing QAbstractItemModel subclasses
The basic functionality for item view classes
Encapsulate a QAbstractLight object in a Qt 3D scene
Abstract model that can be subclassed to create one-dimensional list models
Interface for receiving native events, such as MSG or XCB event structs
The interface for cache implementations
The base of all implementations of OAuth authentication methods
The base of all implementations of OAuth 2 authentication methods
Handles replies to OAuth authentication requests
The base class of a family of classes that expose all functions for each OpenGL version and profile
The base class used by Qt3d to interact with arbitrary input devices
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
An abstract base class for ray casting in 3d scenes
Scrolling area with on-demand scroll bars
QAbstractSeries (PyQt6.QtCharts)
Base class for all Qt Chart series
QAbstractSeries (PyQt6.QtGraphs)
Base class for all Qt Graphs for 2D series
A skeleton contains the joints for a skinned mesh
Integer value within a range
The base functionality common to all socket types
Spinbox and a line edit to display values
TODO
TODO
Abstract model that can be subclassed to create table models
Abstract base class used to implement custom layouts for QTextDocuments
A base class to be used to provide textures
Encapsulates the necessary information to create an OpenGL texture image
TODO
Convenience wrapper around QSensor
Convenience wrapper around QSensorFilter
Reports on linear acceleration along the X, Y and Z axes
QAction (PyQt6.Qt3DInput)
Links a set of QAbstractActionInput that trigger the same event
QAction (PyQt6.QtGui)
Abstraction for user commands that can be added to different user interface components
Event that is generated when a QAction is added, removed, or changed
Groups actions together
Stores Device and Buttons used to trigger an input event
Performs an additive blend of two animation clips based on an additive factor
QLowEnergyAdvertisingParameters::AddressInfo defines the elements of a white list
Enable alpha-to-coverage multisampling mode
Specify alpha reference test
Convenience wrapper around QSensorFilter
Represents one reading from the ambient light sensor
Convenience wrapper around QSensor
A stereo overlay sound
Convenience wrapper around QSensorFilter
Holds readings of the ambient temperature
Convenience wrapper around QSensor
An axis input controlled by an analog input The axis value is controlled like a traditional analog input such as a joystick
Provides key-frame animation capabilities to Qt 3D
Specifies key frame animation data
Class containing the animation data
Enables loading key frame animation data from a file
A controller class for animations
QAnimationGroup (PyQt6.Qt3DAnimation)
A class grouping animations together
QAnimationGroup (PyQt6.QtCore)
Abstract base class for groups of animations
Manages the GUI application's control flow and main settings
Legend marker for an area series
QAreaSeries (PyQt6.QtCharts)
Presents data in area charts
QAreaSeries (PyQt6.QtGraphs)
Presents data in area graphs
Used to calculate skinning transform matrices and set them on shaders
Responsible for handling all the QAbstractAspect subclasses that have been registered with the scene
Defines an attribute and how data should be read from a QBuffer
Attribute (PyQt6.QtGui.QInputMethodEvent)
QInputMethodEvent::Attribute class stores an input method attribute
Attribute (PyQt6.QtQuick.QSGGeometry)
TODO
Attribute (PyQt6.QtQuick3D.QQuick3DGeometry)
TODO
TODO
TODO
Represents a collection of audio samples with a specific format and sample rate
Used for providing custom audio buffers to QMediaRecorder through QMediaCaptureSession
Used for capturing audio data provided by QMediaPlayer
Implements decoding audio
Information about audio devices and their functionality
Manages a three dimensional sound field
Stores audio stream parameter information
Represents an input channel for audio
Defines the position and orientation of the person listening to a sound field defined by QAudioEngine
Represents an output channel for audio
TODO
Interface for sending audio data to an audio output device
Interface for receiving audio data from an audio input device
Authentication object
Abstract class that provides an API to initialize and access a COM object
Static properties and signals for QAxObject
Static properties and signals for QAxWidget
Stores QAbstractAxisInputs used to trigger an input event
Processes velocity or acceleration data from a QAxis
Stores settings for the specified list of Axis
QObject that wraps a COM object
Interface providing common properties of QAxObject and QAxWidget
QWidget that wraps an ActiveX control
B
Base class for all Qt3D backend nodes
Creates and maps backend nodes to their respective frontend nodes
Drawing area for QWindow
QBar3DSeries (PyQt6.QtDataVisualization)
Represents a data series in a 3D bar graph
QBar3DSeries (PyQt6.QtGraphs)
Represents a data series in a 3D bar graph
QBarCategoryAxis (PyQt6.QtCharts)
Adds categories to a chart's axes
QBarCategoryAxis (PyQt6.QtGraphs)
Adds categories to a graph's axes
QBarDataItem (PyQt6.QtDataVisualization)
Container for resolved data to be added to bar graphs
QBarDataItem (PyQt6.QtGraphs)
Container for resolved data to be added to bar graphs
QBarDataProxy (PyQt6.QtDataVisualization)
The data proxy for a 3D bars graph
QBarDataProxy (PyQt6.QtGraphs)
The data proxy for a 3D bars graph
Legend marker for a bar series
Model mapper for bar series
QBarSeries (PyQt6.QtCharts)
Presents a series of data as vertical bars grouped by category
QBarSeries (PyQt6.QtGraphs)
Presents data in bar graphs
QBarSet (PyQt6.QtCharts)
Represents one set of bars in a bar chart
QBarSet (PyQt6.QtGraphs)
Represents one set of bars in a bar graph
Timer events for objects
QOpenGLVertexArrayObject::Binder class is a convenience class to help with the binding and releasing of OpenGL Vertex Array Objects
Array of bits
Monochrome (1-bit depth) pixmaps
Component providing animation playback capabilities of a tree of blend nodes
Specifies the equation used for both the RGB blend equation and the Alpha blend equation
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)
FrameGraph node to transfer a rectangle of pixel values from one region of a render target to another
TODO
Assigns an address to the Bluetooth device
QBluetoothDeviceDiscoveryAgent
Discovers the Bluetooth devices nearby
Stores information about the Bluetooth device
Encapsulates the details of a local QBluetooth device
Enables access to the local Bluetooth device
Access Bluetooth peripherals
Uses the RFCOMM or L2cap protocol to communicate with a Bluetooth device
QBluetoothServiceDiscoveryAgent
Enables you to query for Bluetooth services
Enables access to the attributes of a Bluetooth service
Enables connection to a Bluetooth device running a bluetooth server
Generates a UUID for each Bluetooth service
Can be used to override the bounding volume of an entity
Lines up child widgets horizontally or vertically
Legend marker for a box plot series
Presents data in box-and-whiskers charts
Represents one item in a box-and-whiskers chart
Defines the fill pattern of shapes drawn by QPainter
QBuffer (PyQt6.Qt3DCore)
Provides a data store for raw data to later be used as vertices or uniforms
QBuffer (PyQt6.QtCore)
QIODevice interface for a QByteArray
An axis input controlled by buttons The axis value is controlled by buttons rather than a traditional analog input such as a joystick
Container to organize groups of button widgets
Array of bytes
Holds a sequence of bytes that can be quickly matched in a byte array
C
Describes calendar systems
Access the user's calendar
Monthly based calendar widget allowing the user to select a date
QCamera (PyQt6.Qt3DRender)
Defines a view point through which the scene will be rendered
QCamera (PyQt6.QtMultimedia)
Interface for system camera devices
General information about camera devices
Describes a video format supported by a camera device
Qt3DRender::QCameraLens specifies the projection matrix that will be used to define a Camera for a 3D scene
Access the camera for taking pictures or videos
Class to allow for selection of camera to be used
Legend marker for a candlestick series
Abstract model mapper class for candlestick series
Presents data as candlesticks
Represents a single candlestick item in a candlestick chart
Used for getting the basic information of a capturable window
QCategory3DAxis (PyQt6.QtDataVisualization)
Manipulates an axis of a graph
QCategory3DAxis (PyQt6.QtGraphs)
Manipulates an axis of a graph
Places named ranges on the axis
TODO
Simple CBOR stream decoder, operating on either a QByteArray or QIODevice
Simple CBOR encoder operating on a one-way stream
Defines a channel for a QAnimationClipData. The animation system interpolates each channel component independently except in the case the QChannel is called "Rotation" (case sensitive), it has four QChannelComponents and the same number of keyframes for each QChannelComponent. In that case the interpolation will be performed using SLERP
TODO
Allows to map the channels within the clip onto properties of objects in the application
Allows to map the channels within the clip onto properties of objects in the application
16-bit Unicode character
Manages the graphical representation of the chart's series, legends, and axes
Standalone widget that can display charts
Checkbox with a text label
Contains event parameters for child object events
Contains event parameters for child window changes
Class to clear buffers
Component providing simple animation playback capabilities
Class used for including a clip in a blend tree
Access to the window system clipboard
Enables an additional OpenGL clipping plane that can be in shaders using gl_ClipDistance
TODO
Contains parameters that describe a close event
Compares strings according to a localized collation algorithm
Can be used to speed up string collation
Colors based on RGB, HSV or CMYK values
Displays a color scale as one of the chart's axes
TODO
Dialog widget for specifying colors
TODO
Allows specifying which color components should be written to the currently bound frame buffer
Color space abstraction
Transformation between color spaces
Model/view implementation of a column view
Combines a button with a dropdown list
Defines a possible command-line option
Means for handling the command line options
Vista style command link button
Encapsulates the common Look and Feel of a GUI
Convenience wrapper around QSensor
Convenience wrapper around QSensorFilter
Represents one reading from a compass
Completions based on an item model
Base class of scene nodes that can be aggregated by Qt3DCore::QEntity instances as a component
Access to the details about a compressed help file
QComponent to issue work for the compute shader on GPU
Proxies multiple source models, concatenating their rows
Allows creation of a cone in 3D space
A conical mesh
A conical mesh
Used in combination with QBrush to specify a conical gradient brush
TODO
Access the user's contacts
Contains parameters that describe a context menu event
Event loop for Qt applications without UI
Holds settings related to core data handling process
Way to generate cryptographic hashes
Allows creation of a cuboid in 3D space
A cuboid mesh
A cuboid mesh
Specifies whether front or back face culling is enabled
Mouse cursor with an arbitrary shape
QCustom3DItem (PyQt6.QtDataVisualization)
Adds a custom item to a graph
QCustom3DItem (PyQt6.QtGraphs)
Adds a custom item to a graph
QCustom3DLabel (PyQt6.QtDataVisualization)
Adds a custom label to a graph
QCustom3DLabel (PyQt6.QtGraphs)
Adds a custom label to a graph
QCustom3DVolume (PyQt6.QtDataVisualization)
Adds a volume rendered object to a graph
QCustom3DVolume (PyQt6.QtGraphs)
Adds a volume rendered object to a graph
Allows creation of a cylinder in 3D space
A cylindrical mesh
A cylindrical mesh
D
Serialization of binary data to a QIODevice
Mapping between a section of a data model to widgets
Date functions
Widget for editing dates based on the QDateTimeEdit widget
Date and time functions
QDateTimeAxis (PyQt6.QtCharts)
Adds dates and times to a chart's axis
QDateTimeAxis (PyQt6.QtGraphs)
Adds support for DateTime values to be added to a graph's axis
Widget for editing dates and times
TODO
The base class of D-Bus adaptor classes
The base class for all D-Bus interfaces in the Qt D-Bus binding, allowing access to remote interfaces
Used to marshall and demarshall D-Bus arguments
Represents a connection to the D-Bus bus daemon
Access to the D-Bus bus daemon service
Represents an error received from the D-Bus bus or from remote applications found in the bus
Proxy for interfaces on remote objects
Represents one message sent or received over the D-Bus bus
Enables the programmer to identify the OBJECT_PATH type provided by the D-Bus typesystem
Refers to one pending asynchronous call
Convenient way for waiting for asynchronous replies
TODO
TODO
Allows the user to watch for a bus service change
Enables the programmer to identify the SIGNATURE type provided by the D-Bus typesystem
Holds one Unix file descriptor
Enables the programmer to identify the variant type provided by the D-Bus typesystem
Marks a deadline in the future
Enables remapping depth values written into the depth buffer
Tests the fragment shader's depth value against the depth of a sample being written to
QDesignerActionEditorInterface
Allows you to change the focus of Qt Widgets Designer's action editor
Allows you to add pages to a custom multi-page container in Qt Widgets Designer's workspace
QDesignerCustomWidgetCollectionInterface
Allows you to include several custom widgets in one single library
QDesignerCustomWidgetInterface
Enables Qt Widgets Designer to access and construct custom widgets
Allows you to access Qt Widgets Designer's various components
QDesignerFormWindowCursorInterface
Allows you to query and modify a form window's widget selection, and in addition modify the properties of all the form's widgets
Allows you to query and manipulate form windows appearing in Qt Widgets Designer's workspace
QDesignerFormWindowManagerInterface
Allows you to manipulate the collection of form windows in Qt Widgets Designer, and control Qt Widgets Designer's form editing actions
Allows you to manipulate a widget's member functions which is displayed when configuring connections using Qt Widgets Designer's mode for editing signals and slots
QDesignerObjectInspectorInterface
Allows you to change the focus of Qt Widgets Designer's object inspector
QDesignerPropertyEditorInterface
Allows you to query and manipulate the current state of Qt Widgets Designer's property editor
QDesignerPropertySheetExtension
Allows you to manipulate a widget's properties which is displayed in Qt Designer's property editor
Allows you to add custom menu entries to Qt Widgets Designer's task menu
Allows you to control the contents of Qt Widgets Designer's widget box
Methods for accessing common desktop services
Rounded range control (like a speedometer or potentiometer)
The base class of dialog windows
Widget that presents buttons in a layout that is appropriate to the current widget style
Default implementation of the phong lighting effect where the diffuse light component is read from a texture map
Default implementation of the phong lighting effect where the diffuse and specular light components are read from texture maps
Default implementation of the phong lighting effect
Access to directory structures and their contents
Encapsulate a Directional Light object in a Qt 3D scene
Iterator for directory entrylists
FrameGraph node to issue work for the compute shader on GPU
Enable dithering
Stores information about a domain name record
Stores information about a host address record
Represents a DNS lookup
Stores information about a DNS MX record
TODO
Stores information about a DNS SRV record
Stores information about a DNS TXT record
Stores information about a DNS TLSA record
Widget that can be docked inside a QMainWindow or floated as a top-level window on the desktop
Represents one attribute of a QDomElement
Represents an XML CDATA section
Represents a generic string in the DOM
Represents an XML comment
Represents an XML document
Tree of QDomNodes which is not usually a complete QDomDocument
The representation of the DTD in the document tree
Represents one element in the DOM tree
Represents an XML entity
Represents an XML entity reference
Information about the features of the DOM implementation
Contains a collection of nodes that can be accessed by name
The base class for all the nodes in a DOM tree
List of QDomNode objects
Represents an XML notation
Represents an XML processing instruction
Represents text data in the parsed XML document
Spin box widget that takes doubles
Range checking of floating-point numbers
Support for MIME-based drag and drop data transfer
Event which is sent to a widget when a drag and drop action enters it
Event that is sent to a widget when a drag and drop action leaves it
Event which is sent while a drag and drop action is in progress
Event which is sent when a drag and drop action is completed
Contains event parameters for dynamic property change events
E
Easing curves for controlling animation
Base class for effects in a Qt 3D scene
Fast way to calculate elapsed times
QPainterPath::Element class specifies the position and type of a subpath
Contains parameters that describe an enter event
Qt3DCore::QEntity is a Qt3DCore::QNode subclass that can aggregate several Qt3DCore::QComponent instances that will specify its behavior
Encapsulate an environment light object in a Qt 3D scene
Error message display dialog
The base class of all event classes. Event objects contain event parameters
Means of entering and leaving an event loop
Means to quit an event loop when it is no longer needed
Information about a point in a QPointerEvent
TODO
Contains event parameters for expose events
Allows you to create a factory that is able to make instances of custom extensions in Qt Designer
Extension management facilities for Qt Widgets Designer
TODO
Allows creation of a 3D extruded text in 3D space
A 3D extruded Text mesh
F
Interface for reading from and writing to files
Interface for reading from and writing to open files
Dialog that allows users to select files or directories
File icons for the QFileSystemModel class
OS-independent API to retrieve information about file system entries
Event that will be sent when there is a request to open a file or a URL
Convenient way of selecting file variants
Data model for the local filesystem
Interface for monitoring files and directories for modifications
Storage for filter keys and their values
TODO
TODO
Allows controlling the scene camera from the first person perspective
Contains event parameters for widget focus events
Focus frame which can be outside of a widget's normal paintable area
Specifies a query for a font used for drawing text
Combobox that lets the user select a font family
Information about the fonts available in the underlying window system
Dialog widget for selecting a font
General information about fonts
Font metrics information
Font metrics information
Represents a variable axis in a font
TODO
Used to dynamically construct user interfaces from UI files at run-time
Convenience class to simplify the construction of QHttpMultiPart objects
Convenience class to simplify the construction of QHttpPart objects
Manages forms of input widgets and their associated labels
Default FrameGraph implementation of a forward renderer
The base class of widgets that can have a frame
Provides a way to have a synchronous function executed each frame
Base class of all FrameGraph configuration nodes
QByteArray::FromBase64Result class holds the result of a call to QByteArray::fromBase64Encoding
Defines front and back facing polygons
Enable frustum culling for the FrameGraph
G
Internal helper class for marshalling arguments
Internal helper class for marshalling arguments
Represents an address of a QGeoLocation
Describes the parameters of an area or region to be monitored for proximity
Enables the detection of proximity changes for a specified set of coordinates
Defines a circular geographic area
Defines a geographical position on the surface of the Earth
Represents basic information about a location
Encapsulates geometry
Encapsulates geometry rendering
Encapsulates geometry details
Defines a geographic path
Defines a geographic polygon
Contains information gathered on a global position, direction and velocity at a particular point in time
Abstract base class for the distribution of positional updates
Defines a rectangular geographic area
Contains basic information about a satellite
Abstract base class for the distribution of satellite information updates
Defines a geographic area
Represents a gesture, containing properties that describe the corresponding user input
The description of triggered gestures
The infrastructure for gesture recognition
Direct access to the internal glyphs in a font
Material that implements the Gooch shading model, popular in CAD and CAM applications
Used in combination with QBrush to specify gradient fills
Represents an anchor between two items in a QGraphicsAnchorLayout
Layout where one can anchor widgets together in Graphics View
Identifies the API required for the attached QTechnique
Blur effect
Colorize effect
Drop shadow effect
The base class for all graphics effects
Ellipse item that you can add to a QGraphicsScene
Grid layout for managing widgets in Graphics View
The base class for all graphical items in a QGraphicsScene
Container that treats a group of items as a single item
The base class for all layouts in Graphics View
Can be inherited to allow your custom items to be managed by layouts
Horizontal or vertical layout for managing widgets in Graphics View
Line item that you can add to a QGraphicsScene
Base class for all graphics items that require signals, slots and properties
Opacity effect
Path item that you can add to a QGraphicsScene
TODO
Pixmap item that you can add to a QGraphicsScene
Polygon item that you can add to a QGraphicsScene
Proxy layer for embedding a QWidget in a QGraphicsScene
Rectangle item that you can add to a QGraphicsScene
Rotation transformation around a given axis
Scale transformation
Surface for managing a large number of 2D graphical items
QGraphicsSceneContextMenuEvent
Context menu events in the graphics view framework
Events for drag and drop in the graphics view framework
Base class for all graphics view related events
Events when a tooltip is requested
Hover events in the graphics view framework
Mouse events in the graphics view framework
Events for widget moving in the graphics view framework
Events for widget resizing in the graphics view framework
Wheel events in the graphics view framework
Simple text path item that you can add to a QGraphicsScene
QGraphicsItem that can be used to render the contents of SVG files
Text item that you can add to a QGraphicsScene to display formatted text
Abstract base class for building advanced transformations on QGraphicsItems
Graphics item which display video produced by a QMediaPlayer or QCamera
Widget for displaying the contents of a QGraphicsScene
The base class for all widget items in a QGraphicsScene
TODO
TODO
Visual style for graphs
Lays out widgets in a grid
Group box frame with a title
Manages the GUI application's control flow and main settings
Convenience wrapper around QSensor
Convenience wrapper around QSensorFilter
Represents one reading from the gyroscope sensor
H
Horizontal model mapper for bar series
Lines up widgets horizontally
Horizontal model mapper for box plot series
Horizontal model mapper for a candlestick series
Header row or header column for item views
QHeightMapSurfaceDataProxy (PyQt6.QtDataVisualization)
Base proxy class for Q3DSurface
QHeightMapSurfaceDataProxy (PyQt6.QtGraphs)
Base proxy class for Q3DSurfaceWidgetItem
Item for use with QHelpContentModel
Model that supplies content to views
Tree view for displaying help content model items
Access to contents and indices of the help engine
The core functionality of the help system
Event that is used to request helpful information about a particular point in a widget
Details for the filters used by QHelpFilterEngine
Filtered view of the help contents
Widget that allows for creating, editing and removing filters
Model that supplies index keywords to views
List view displaying the QHelpIndexModel
TODO
Access to widgets reusable to integrate fulltext search as well as to index and search documentation
Access to index and search documentation
Contains the field name and the associated search term
Simple line edit or an advanced widget to enable the user to input a search term in a standardized input mask
The data associated with the search result
Text browser to display search results
Event which is sent after a widget is hidden
TODO
Presents a series of data as horizontal bars grouped by category
Presents a series of categorized data as a percentage of each category
Presents a series of data as horizontally stacked bars, with one bar per category
IP address
Static functions for host name lookups
Contains parameters that describe a mouse event
Horizontal model mapper for pie series
Specifies that a host supports HTTP Strict Transport Security policy (HSTS)
Controls HTTP/1 parameters and settings
Controls HTTP/2 parameters and settings
Class for holding HTTP headers
Resembles a MIME multipart message to be sent over HTTP
Holds a body part to be used inside a HTTP multipart MIME message
Convenience wrapper around QSensorFilter
Holds readings from the humidity sensor
Convenience wrapper around QSensor
Horizontal model mapper for line, spline, and scatter series
I
Scalable icons in different modes and states
Indicates that a main icon drag has begun
Abstract base class for QIcon renderers
TODO
Proxies its source model unmodified
Hardware-independent image representation that allows direct access to the pixel data, and can be used as a paint device
Used for the recording of media content
Defines the common image I/O interface for all image formats in Qt
Format independent interface for reading images from files or other devices
Format independent interface for writing images to files or other devices
Responsible for creating physical devices and handling associated jobs
Represents a set of QAbstractActionInput's that must be triggerd at once
Describes a device from which a QInputEvent originates
Simple convenience dialog to get a single value from the user
The base class for events that describe user input
Access to the active text input method
Parameters for input method events
Event sent by the input context to input objects
Represents a set of QAbstractActionInput's that must be triggerd one after the other
Holds the pointer to an input event source object
TODO
Validator that ensures a string contains a valid integer within a specified range
The base interface class of all I/O devices in Qt
TODO
TODO
TODO
TODO
TODO
Display and editing facilities for data items from a model
Abstract base class that must be subclassed when implementing new item editor creators
Widgets for editing item data in views and delegates
QItemModelBarDataProxy (PyQt6.QtDataVisualization)
Proxy class for presenting data in item models with Q3DBars
QItemModelBarDataProxy (PyQt6.QtGraphs)
Proxy class for presenting data in item models with Q3DBarsWidgetItem
QItemModelScatterDataProxy (PyQt6.QtDataVisualization)
Proxy class for presenting data in item models with Q3DScatter
QItemModelScatterDataProxy (PyQt6.QtGraphs)
Proxy class for presenting data in item models with Q3DScatterWidgetItem
QItemModelSurfaceDataProxy (PyQt6.QtDataVisualization)
Proxy class for presenting data in item models with Q3DSurface
QItemModelSurfaceDataProxy (PyQt6.QtGraphs)
Proxy class for presenting data in item models with Q3DSurfaceWidgetItem
Manages information about selected items in a model
Keeps track of a view's selected items
Manages information about a range of selected items in a model
iterator (PyQt6.QtGui.QTextBlock)
QTextBlock::iterator class provides an iterator for reading the contents of a QTextBlock
iterator (PyQt6.QtGui.QTextFrame)
Iterator for reading the contents of a QTextFrame
J
Used to transforms parts of skinned meshes
Environment for evaluating JavaScript code
Represents a value on the JavaScript heap belonging to a QJSEngine
Way to read and write JSON documents
TODO
Encapsulates a value in JSON
TODO
TODO
Operates on primitive types in JavaScript semantics
Acts as a container for Qt/JavaScript data types
Java-style iterator for QJSValue
K
QPixmapCache::Key class can be used for efficient access to the QPixmapCache
In charge of dispatching keyboard events to attached QQKeyboardHandler objects
Provides keyboard event notification
Stores a combination of a key with optional modifiers
QKeyEvent (PyQt6.Qt3DInput)
Event type send by KeyBoardHandler
QKeyEvent (PyQt6.QtGui)
Describes a key event
TODO
A base class for handling keyframes
A class implementing simple keyframe animation to a QTransform
Encapsulates a key sequence as used by shortcuts
Allows to input a QKeySequence
L
Text or image display
Way of filtering which entities will be rendered
Controls layers drawn in a frame graph branch
The base class of geometry managers
Abstract item that a QLayout manipulates
Displays a number with LCD-like digits
Displays the legend of a chart
TODO
Abstract object that can be used to access markers within a legend
Performs a linear interpolation of two animation clips based on a normalized factor
Way of controlling the complexity of rendered entities based on their size on the screen
Simple spherical volume, defined by its center and radius
Provides a way of enabling child entities based on distance or screen size
Loads shared libraries at runtime
Information about the Qt library
TODO
TODO
TODO
Convenience wrapper around QSensorFilter
Represents one reading from the light sensor
Convenience wrapper around QSensor
Two-dimensional vector using integer precision
Used in combination with QBrush to specify a linear gradient brush
One-line text editor
Two-dimensional vector using floating point precision
QLineSeries (PyQt6.QtCharts)
Presents data in line charts
QLineSeries (PyQt6.QtGraphs)
Presents data in line graphs
Specifies the width of rasterized lines
List or icon view onto a model
Item-based list widget
Item for use with the QListWidget item view class
Converts between numbers and their string representations in various languages
Local socket based server
Local socket
Access the user's location
Locking between processes using a file
Represents a category, or 'area' in the logging infrastructure
Allows the user to define a set of actions that they wish to use within an application
Responsible for handling frame synchronization jobs
QLogValue3DAxisFormatter (PyQt6.QtDataVisualization)
Formatting rules for a logarithmic value axis
QLogValue3DAxisFormatter (PyQt6.QtGraphs)
Formatting rules for a logarithmic value axis
Adds a logarithmic scale to a chart's axis
Represents the data to be broadcast during Bluetooth Low Energy advertising
QLowEnergyAdvertisingParameters
Represents the parameters used for Bluetooth Low Energy advertising
Stores information about a Bluetooth Low Energy service characteristic
Used to set up GATT service data
QLowEnergyConnectionParameters
Used when requesting or reporting an update of the parameters of a Bluetooth LE connection
Access to Bluetooth Low Energy Devices
Stores information about the Bluetooth Low Energy descriptor
Used to create GATT service data
Represents an individual service on a Bluetooth Low Energy Device
Used to set up GATT service data
M
Convenience wrapper around QSensor
Convenience wrapper around QSensorFilter
Represents one reading from the magnetometer
Main application window
Defines the four margins of a rectangle
Defines the four margins of a rectangle
Abstract base for custom 32-bit mask generators
Provides an abstract class that should be the base of all material component classes in a scene
TODO
TODO
TODO
TODO
TODO
TODO
TODO
TODO
Represents a 4x4 transformation matrix in 3D space
Area in which MDI windows are displayed
Subwindow class for QMdiArea
Allows capturing of audio and video content
Information about available multimedia input and output devices
Describes an encoding format for a multimedia file or stream
Provides meta-data for media files
Allows the playing of a media files
Used for encoding and recording a capture session
Represents a set of zero or more disjoint time intervals
Class to emplace a memory barrier
Menu widget for use in menu bars, context menus, and other popup menus
Horizontal menu bar
A custom mesh loader
Way to generate hash-based message authentication codes
Modal dialog for informing the user or for asking the user a question and receiving an answer
Additional information about a log message
Generates log messages
Additional information about a class
Meta-data about an enumerator
Default implementation of PBR lighting
Meta-data about a member function
TODO
Meta-data about a property
Manages named types in the meta-object system
Access the microphone for monitoring or recording sound
Container for data that records information about its MIME type
Maintains a database of MIME types
Describes types of file or data, represented by a MIME type string
Used to locate data in a data model
Holds a role and the data associated to that role
Span over QModelRoleData objects
A class implementing blend-shape morphing animation
Default implementation of the phong lighting effect
A class providing morph targets to blend-shape animation
Delegates mouse events to the attached MouseHandler objects
QMouseEvent (PyQt6.Qt3DInput)
Qt3DCore::QMouseEvent contains parameters that describe a mouse event
QMouseEvent (PyQt6.QtGui)
Contains parameters that describe a mouse event
TODO
Provides a means of being notified about mouse events when attached to a QMouseDevice instance
Contains event parameters for move events
Convenience class for playing movies with QImageReader
Enable multisample antialiasing
Access serialization between threads
TODO
N
Contains parameters that describe a gesture event
TODO
Holds a native key used by QSystemSemaphore and QSharedMemory
Filter for matching NDEF messages
NFC NDEF message
NFC MIME record to hold an icon
NFC RTD-SmartPoster
NFC RTD-Text
NFC RTD-URI
NFC NDEF record
Access to notifications for NFC events
Interface for communicating with a target device
Allows the application to send network requests and receive replies
Stores one IP address supported by a network interface, along with its associated netmask and broadcast address
Cache information
Holds one network cookie
Implements a simple jar of QNetworkCookie objects
The data and metadata of a UDP datagram
Very basic disk cache
Exposes various network information through native backends
Listing of the host's IP addresses and network interfaces
Network layer proxy
Fine-grained proxy selection
Used to query the proxy settings for a socket
Contains the data and headers for a request sent with QNetworkAccessManager
Holds a request to be sent with QNetworkAccessManager
Convenience class for grouping remote server endpoints that share common network request properties
Positional information using a NMEA data source
Satellite information using an NMEA data source
The base class of all Qt3D node classes used to build a Qt3D scene
Uniquely identifies a QNode
TODO
Disable depth write
When a Qt3DRender::QNoDraw node is present in a FrameGraph branch, this prevents the renderer from rendering any primitive
When a Qt3DRender::QNoPicking node is present in a FrameGraph branch, this prevents the render aspect from performing picking selection for the given branch
QNormalDiffuseMapAlphaMaterial
Specialization of QNormalDiffuseMapMaterial with alpha coverage and a depth test performed in the rendering pass
Default implementation of the phong lighting and bump effect where the diffuse light component is read from a texture map and the normals of the mesh being rendered from a normal texture map
QNormalDiffuseSpecularMapMaterial
Default implementation of the phong lighting and bump effect where the diffuse and specular light components are read from texture maps and the normals of the mesh being rendered from a normal texture map
O
Implementation of the OAuth 1 Protocol
Implements OAuth 1 signature methods
Implementation of the Authorization Code Grant flow
QOAuth2DeviceAuthorizationFlow
TODO
TODO
TODO
Handles private/custom and https URI scheme redirects
The base class of all Qt objects
Watches the lifetime of multiple QObjects
Instantiates a component that can be used to interact with a QEntity by a process known as picking
This class represents Online Certificate Status Protocol response
Represents an offscreen surface in the underlying platform
TODO
Functions for creating and managing OpenGL buffer objects
Represents a native OpenGL context, enabling OpenGL rendering on a QSurface
Represents a group of contexts sharing OpenGL resources
Enables logging of OpenGL debugging messages
Wraps an OpenGL debug message
Encapsulates an OpenGL framebuffer object
QOpenGLFramebufferObjectFormat
Specifies the format of an OpenGL framebuffer object
All functions for OpenGL 2.0 specification
All functions for OpenGL 2.1 specification
All functions for OpenGL 4.1 core profile
Enables painting to an OpenGL context using QPainter
Describes the pixel storage modes that affect the unpacking of pixels during texture upload
Allows OpenGL shaders to be compiled
Allows OpenGL shader programs to be linked and used
Encapsulates an OpenGL texture object
Convenient way to draw textured quads via OpenGL
Wraps a sequence of OpenGL timer query objects
Wraps an OpenGL timer query object
QOpenGLVersionFunctionsFactory
Provides access to OpenGL functions for a specified version and profile
Represents the version and if applicable the profile of an OpenGL context
Wraps an OpenGL Vertex Array Object
Widget for rendering OpenGL graphics
Convenience subclass of QWindow to perform OpenGL painting
Information about the operating system version
TODO
Allows controlling the scene camera along orbital path
Convenience wrapper around QSensorFilter
Represents one reading from the orientation sensor
Convenience wrapper around QSensor
P
Represents a paint device that supports multiple pages
Describes the size, orientation and margins of a page
Represents a collection of page ranges
Configuration dialog for the page-related options on a printer
Describes the size and name of a defined page size
TODO
The base class of objects that can be painted on with QPainter
Convenience subclass of QWindow that is also a QPaintDevice
A QAbstractTextureImage that can be written through a QPainter
Abstract definition of how QPainter draws to a given device on a given platform
Information about the active paint engine's current state
Performs low-level painting on widgets and other paint devices
Container for painting operations, enabling graphical shapes to be constructed and reused
Used to generate fillable outlines for a given painter path
RAII convenience class for balanced QPainter::save() and QPainter::restore() calls
Contains event parameters for paint events
TODO
Contains color groups for each widget state
Describes a panning gesture made by the user
Parallel group of animations
Provides storage for a name and value pair. This maps to a shader uniform
TODO
Pause for QSequentialAnimationGroup
Holds a tree of of links (anchors) within a PDF document, such as the table of contents
Loads a PDF document and renders pages from it
Holds the options to render a page from a PDF document
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)
Holds the geometry and the destination for each link that the specified page contains
TODO
Navigation history within a PDF document
Encapsulates the rendering of pages of a PDF document
A widget for selecting a PDF page
Searches for a string in a PDF document and holds the results
Defines a range of text that has been selected on one page in a PDF document, and its geometric boundaries
A PDF viewer widget
Class to generate PDFs that can be used as a paint device
Defines how a QPainter should draw lines and outlines of shapes
Presents a series of categorized data as a percentage of each category
An opaque wrapper of a typed permission
Used to locate data in a data model
Default implementation for rendering the color properties set for each vertex
Default implementation of the phong lighting effect with alpha
Default implementation of the phong lighting effect
Holds information when an object is picked
Can be used to provide an alternate QGeometryView used only for picking
Specifies how entity picking is handled
Holds information when a segment of a line is picked
Holds information when a segment of a point cloud is picked
Holds information when a triangle is picked
Paint device that records and replays QPainter commands
Legend marker for a pie series
Model mapper for pie series
QPieSeries (PyQt6.QtCharts)
Presents data in pie charts
QPieSeries (PyQt6.QtGraphs)
Presents data in pie graphs
QPieSlice (PyQt6.QtCharts)
Represents a single slice in a pie series
QPieSlice (PyQt6.QtGraphs)
Represents a single slice in a pie series
Describes a pinch gesture made by the user
Class for describing different pixel layouts in graphics buffers
Off-screen image representation that can be used as a paint device
Application-wide cache for pixmaps
This class is used in conjunction with the QPainter::drawPixmapFragments() function to specify how a pixmap, or sub-rect of a pixmap, is drawn
Implements a plain text layout for QTextDocument
Widget that is used to edit and display plain text
Allows creation of a plane in 3D space
A square planar mesh
A square planar mesh
Used to notify about native platform surface events
Loads a plugin at run-time
Defines a point in the plane using integer precision
TODO
A base class for pointer events
Defines a point in the plane using floating point precision
Describes a device from which mouse, touch or tablet events originate
Identifies a unique object, such as a tagged token or stylus, which is used with a pointing device
Encapsulate a Point Light object in a Qt 3D scene
Specifies the size of rasterized points. May either be set statically or by shader programs
Presents data in polar charts
List of points using integer precision
List of points using floating point precision
Sets the scale and steps to calculate depth values for polygon offsets
Convenience wrapper around QSensorFilter
Holds readings from the pressure sensor
Convenience wrapper around QSensor
TODO
Dialog for specifying the printer's configuration
Defines an interface for how QPrinter interacts with a given printing subsystem
Paint device that paints on a printer
Gives access to information about existing printers
Dialog for previewing and configuring page layouts for printer output
Widget for previewing page layouts for printer output
Used to start external programs and to communicate with them
Holds the environment variables that can be passed to a program
Horizontal or vertical progress bar
Feedback on the progress of a slow operation
Animates Qt properties
TODO
TODO
QProximityFilter (PyQt6.Qt3DRender)
Select entities which are within a distance threshold of a target entity
QProximityFilter (PyQt6.QtSensors)
Convenience wrapper around QSensorFilter
Represents one reading from the proximity sensor
Convenience wrapper around QSensor
Convenience class that simplifies dynamically overriding QStyle elements
Command button
TODO
QPyDesignerCustomWidgetCollectionPlugin
TODO
TODO
QPyDesignerMemberSheetExtension
TODO
QPyDesignerPropertySheetExtension
TODO
TODO
Q
Allows you to control QML file loading
Convenient way to load an application from a single QML file
Encapsulates a QML component definition
Defines a context within a QML engine
Environment for instantiating QML components
Abstract base for custom QML extension plugins
Encapsulates a QML error
Evaluates JavaScript in a QML context
Abstract base for custom QML extension plugins with custom type registration functions
A class for applying a QFileSelector to QML file loading
Used to register image providers in the QML engine
Instances drive the progress of QQmlIncubators
Allows QML objects to be created asynchronously
Allows the manipulation of QQmlListProperty properties
QQmlNetworkAccessManagerFactory
Creates QNetworkAccessManager instances for a QML engine
Updates on the QML parser state
Abstracts accessing properties on objects created from QML
Allows you to set key-value pairs that can be used in QML bindings
Interface for property value sources such as animations and bindings
Encapsulates a script and its context
TODO
Represents a quaternion consisting of a vector and scalar
Helper class for selecting correct surface format
Base class for defining custom geometry
Base class of all 3D nodes and resources
Base class for defining custom texture data
Interface for asynchronous control of QML image requests
Convenience class for integrating OpenGL rendering using a framebuffer object (FBO) with Qt Quick
Controls lower level graphics settings for the QQuickWindow
Opaque container for native graphics objects representing graphics devices or contexts
Interface for supporting pixmaps and threaded image requests in QML
Interface for asynchronous image loading in QQuickAsyncImageProvider
The most basic of all visual items in Qt Quick
Contains the result from QQuickItem::grabToImage()
Way to use the QPainter API in the QML Scene Graph
Mechanism for rendering the Qt Quick scenegraph onto an offscreen render target in a fully application-controlled manner
Opaque container for native graphics resources specifying a render target, and associated metadata
Access to the QTextDocument of QQuickTextEdit
Interface for loading custom textures from QML
Window for displaying a Qt Quick user interface
Web engine profile shared by multiple pages
Widget for displaying a Qt Quick user interface
The window for displaying a graphical QML scene
R
Used in combination with QBrush to specify a radial gradient brush
Radio button with a text label
Allows one to obtain random values from a high-quality Random Number Generator
TODO
Render state allows to control the type of rasterization to be performed
Convenience class for using QPainter on a QWindow
Access to a single physical instance of a font
Qt3DRender::QRayCaster is used to perform ray casting tests in 3d world coordinates
Details of a hit when casting a ray through a model
Convenience class that simplifies locking and unlocking read-write locks for read access
Read-write locking
TODO
Defines a rectangle in the plane using integer precision
Defines a finite rectangle in the plane using floating point precision
Access serialization between threads
Specifies a clip region for a painter
Pattern matching using regular expressions
The results of a matching a QRegularExpression against a string
QRegularExpressionMatchIterator
Iterator on the results of a global match of a QRegularExpression object against a string
Used to check a string against a regular expression
QRemoteObjectAbstractPersistedStore
A class which provides the methods for setting PROP values of a replica to value they had the last time the replica was used
A dynamically instantiated Replica
A (Host) Node on a Qt Remote Objects network
Base functionality common to Host and RegistryHost classes
A node on a Qt Remote Objects network
A class holding information about Source objects available on the Qt Remote Objects network
A (Host/Registry) node on a Qt Remote Objects network
A class interacting with (but not implementing) a Qt API on the Remote Object network
TODO
QRemoteObjectSourceLocationInfo
TODO
TODO
Class
Holds settings related to available rendering engines
Frame graph node for render capture
Receives the result of render capture request
TODO
Encapsulates a Render Pass
Provides storage for vectors of Filter Keys and Parameters
Holds settings related to rendering process and host the active FrameGraph
An abstract base class for all render states
RenderState (PyQt6.QtQuick.QSGMaterialShader)
Encapsulates the current rendering state during a call to QSGMaterialShader::updateUniformData() and the other update type of functions
RenderState (PyQt6.QtQuick.QSGRenderNode)
TODO
FrameGraph node offers a way of specifying a set of QRenderState objects to be applied during the execution of a framegraph branch
Provides a way of specifying the render surface
Encapsulates a target (usually a frame buffer object) which the renderer can render into
Allows the specification of an attachment of a render target (whether it is a color texture, a depth texture, etc... )
Provides a way of specifying a render target
A request id handle
Contains event parameters for resize events
Interface for reading directly from resources
Convenience wrapper for QNetworkAccessManager
Convenience wrapper for QNetworkReply
Struct contains a 64-bit RGB color
Convenience wrapper around QSensorFilter
Represents one reading from the rotation sensor
Convenience wrapper around QSensor
Rectangle or line that can indicate a selection or a boundary
The base class for all runnable objects
S
Interface for safely writing to files
TODO
QScatter3DSeries (PyQt6.QtDataVisualization)
Represents a data series in a 3D scatter graph
QScatter3DSeries (PyQt6.QtGraphs)
Represents a data series in a 3D scatter graph
QScatterDataItem (PyQt6.QtDataVisualization)
Container for resolved data to be added to scatter graphs
QScatterDataItem (PyQt6.QtGraphs)
Container for resolved data to be added to scatter graphs
QScatterDataProxy (PyQt6.QtDataVisualization)
The data proxy for 3D scatter graphs
QScatterDataProxy (PyQt6.QtGraphs)
The data proxy for 3D scatter graphs
QScatterSeries (PyQt6.QtCharts)
Presents data in scatter charts
QScatterSeries (PyQt6.QtGraphs)
Presents data in scatter graphs
Provides the facility to load an existing Scene
Discards fragments that fall outside of a certain rectangular portion of the screen
Used to query screen properties
This class is used for capturing a screen
Performe ray casting test based on screen coordinates
Scrolling view onto another widget
Vertical or horizontal scroll bar
Enables kinetic scrolling for any scrolling widget or graphics item
Stores the settings for a QScroller
Sent when scrolling
Sent in preparation of scrolling
Enables seamless cubemap texture filtering
TODO
General counting semaphore
Exception-safe deferral of a QSemaphore::release() call
Represents a single hardware sensor
Efficient callback facility for asynchronous notifications of sensor changes
Holds the readings from the sensor
Sequential group of animations
Provides functions to access serial ports
Provides information about existing serial ports
Access to the session manager
FrameGraphNode used to insert a fence in the graphics command stream
Persistent platform-independent application settings
Serves as a baseclass for geometry based nodes
Implements the clipping functionality in the scene graph
Serves as a baseclass for dynamically changing textures, such as content that is rendered to FBO's
Convenient way of rendering solid colored geometry in the scene graph
Low-level storage for graphics primitives in the Qt Quick Scene Graph
Used for all rendered content in the scene graph
Provided for convenience to easily draw textured content using the QML scene graph
Encapsulates rendering state for a shader program
Represents a graphics API independent shader program
TODO
The base class for all nodes in the scene graph
Used to change opacity of nodes
Convenient way of rendering textured geometry in the scene graph
TODO
Convenience class for drawing solid filled rectangles using scenegraph
An interface providing access to some of the graphics API specific internals of the scenegraph
Represents a set of custom rendering commands targeting the graphics API that is in use by the scenegraph
Convenience class for drawing solid filled rectangles using scenegraph
Provided for convenience to easily draw textured content using the QML scene graph
Class for drawing text layouts and text documents in the Qt Quick scene graph
The base class for textures used in the scene graph
Convenient way of rendering textured geometry in the scene graph
Encapsulates texture based entities in QML
Implements transformations in the scene graph
Convenient way of rendering per-vertex colored geometry in the scene graph
Provides a way of specifying values of a Uniform Block or a shader structure
Provides Image access to shader programs
Encapsulates a Shader Program
Generates a Shader Program content from loaded graphs
Allows to use a textureId from a separate OpenGL context in a Qt 3D scene
Access to a shared memory segment
Used to create keyboard shortcuts
Event which is generated when the user presses a key combination
Event that is sent when a widget is shown
Exception-safe wrapper around QObject::blockSignals()
TODO
Bundles signals from identifiable senders
Enables introspection of signal emission
TODO
A base class for pointer events containing a single point, such as mouse events
Defines the size of a two-dimensional object using integer point precision
Defines the size of a two-dimensional object using floating point precision
Resize handle for resizing top-level windows
Layout attribute describing horizontal and vertical resizing policy
Holds the data for a skeleton to be used with skinned meshes
Used to load a skeleton of joints from file
TODO
Qt3DExtras::QSkyboxEntity is a convenience Qt3DCore::QEntity subclass that can be used to insert a skybox in a 3D scene
Vertical or horizontal slider
Support for monitoring activity on a file descriptor
Support for sorting and filtering data passed between another model and a view
Provides storage for the sort types to be used
Way to play low latency sound effects
Blank space in a layout
A sound object in 3D space
Allows creation of a sphere in 3D space
A spherical mesh
A spherical mesh
Spin box widget
Splash screen that can be shown during application startup
TODO
QSplineSeries (PyQt6.QtCharts)
Presents data as spline charts
QSplineSeries (PyQt6.QtGraphs)
Presents data in spline graphs
Implements a splitter widget
Handle functionality for the splitter
Encapsulate a Spot Light object in a Qt 3D scene
TODO
TODO
TODO
TODO
Handles a connection to a database
Abstract base class for accessing specific SQL databases
The base class for SQL driver factories
SQL database error information
Manipulates the fields in SQL database tables and views
Functions to manipulate and describe database indexes
Means of executing and manipulating SQL statements
Read-only data model for SQL result sets
Encapsulates a database record
Stores information about an SQL foreign key
Delegate that is used to display and edit data from a QSqlRelationalTableModel
Editable data model for a single database table, with foreign key support
Abstract interface for accessing data from specific SQL databases
Editable data model for a single database table
TODO
Convenient API for an X509 certificate
API for accessing the extensions of an X509 certificate
Represents an SSL cryptographic cipher
Holds the configuration and state of an SSL connection
Interface for Diffie-Hellman parameters for servers
Represents an elliptic curve for use by elliptic-curve cipher algorithms
SSL error
Interface for private and public keys
Authentication data for pre shared keys (PSK) ciphersuites
Implements an encrypted, secure TCP server over TLS
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
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
Methods for accessing standard paths
TODO
TODO
Enables optimized drawing of text when the text and its layout is updated rarely
Horizontal bar suitable for presenting status information
Event that is used to show messages in a status bar
Controls the front and back writing of individual bits in the stencil planes
Specifies stencil operation
Sets the actions to be taken when stencil and depth tests fail
Specifies arguments for the stecil test
Specifies arguments for stencil test
Provides information about currently mounted storage and drives
Base class for encoding and decoding text
TODO
State-based decoder for text
State-based encoder for text
Model that supplies strings to views
Abstract base class that encapsulates the look and feel of a GUI
Display and editing facilities for data items from a model
Creates QStyle objects
Style hints that return more than basic data types
Style hints that return a QRegion
Style hints that return a QVariant
Contains platform specific hints and settings
Stores the parameters used by QStyle functions
Used to describe the parameters for drawing buttons
Used to describe the parameter for drawing a combobox
Used to hold parameters that are common to all complex controls
Used to describe the parameters for drawing a dock widget
Used to describe the parameters for drawing a focus rectangle with QStyle
Used to describe the parameters for drawing a frame
Used to describe the parameters needed to draw a QGraphicsItem
Describes the parameters for drawing a group box
Used to describe the parameters for drawing a header
Used to describe the parameters for drawing a header
Used to describe the parameter necessary for drawing a menu item
Used to describe the parameters necessary for drawing a progress bar
Used to describe the parameters needed for drawing a rubber band
Used to describe the parameter for drawing a size grip
Used to describe the parameters needed for drawing a slider
Used to describe the parameters necessary for drawing a spin box
Used to describe the parameters for drawing a tab bar
Used to describe the base of a tab bar, i.e. the part that the tab bar usually overlaps with
Used to describe the parameters for drawing the frame around a tab widget
Used to describe the parameters for drawing a title bar
Used to describe the parameters for drawing a toolbar
Used to describe the parameters needed for drawing a tool box
Used to describe the parameters for drawing a tool button
Used to describe the parameters used to draw an item in a view widget
Convenience class for drawing QStyle elements inside a widget
Enables or disables entire subtrees of framegraph nodes
Abstraction of renderable surfaces in Qt
QSurface3DSeries (PyQt6.QtDataVisualization)
Represents a data series in a 3D surface graph
QSurface3DSeries (PyQt6.QtGraphs)
Represents a data series in a 3D surface graph
QSurfaceDataItem (PyQt6.QtDataVisualization)
Container for resolved data to be added to surface graphs
QSurfaceDataItem (PyQt6.QtGraphs)
Container for resolved data to be added to surface graphs
QSurfaceDataProxy (PyQt6.QtDataVisualization)
The data proxy for a 3D surface graph
QSurfaceDataProxy (PyQt6.QtGraphs)
The data proxy for a 3D surface graph
Represents the format of a QSurface
TODO
TODO
Paint device that is used to create SVG drawings
Used to draw the contents of SVG files onto paint devices
Widget that is used to display the contents of Scalable Vector Graphics (SVG) files
Describes a swipe gesture made by the user
Allows you to define syntax highlighting rules, and in addition you can use the class to query a document's current formatting or user data
Information about the system
General counting system semaphore
Icon for an application in the system tray
T
TODO
TODO
Tab bar, e.g. for use in tabbed dialogs
Contains parameters that describe a Tablet event
Default model/view implementation of a table view
Item-based table view with a default model
Item for use with the QTableWidget class
Way to interact with selection in a model without using model indexes and a selection model
Stack of tabbed widgets
TODO
TODO
Describes a tap-and-hold (aka LongTap) gesture made by the user
TODO
Describes a tap gesture made by the user
TODO
TODO
TODO
TCP-based server
TCP socket
Encapsulates a Technique
A QFrameGraphNode used to select QTechniques to use
Creates a unique directory for temporary use
I/O device that operates on temporary files
TODO
Allows creation of a 2D text in 3D space
Container for text fragments in a QTextDocument
Formatting information for blocks of text in a QTextDocument
Container for text blocks within a QTextDocument
Used to associate custom data with blocks of text
Way of finding Unicode text boundaries in a string
Rich text browser with hypertext navigation
Formatting information for characters in a QTextDocument
Offers an API to access and modify QTextDocuments
Holds formatted text
Represents a piece of formatted text from a QTextDocument
Format-independent interface for writing a QTextDocument to files or other devices
Widget that is used to edit and display both plain and rich text
Formatting information for a QTextDocument
Holds a piece of text in a QTextDocument with a single QTextCharFormat
Represents a frame in a QTextDocument
Formatting information for frames in a QTextDocument
Formatting information for images in a QTextDocument
Represents an inline object in a QAbstractTextDocumentLayout and its implementations
All the information required to draw text in a custom paint engine
Used to lay out and render text
Encapsulates the different types of length used in a QTextDocument
Represents a line of text inside a QTextLayout
Decorated list of items in a QTextDocument
Formatting information for lists in a QTextDocument
Base class for different kinds of objects that can group parts of a QTextDocument together
Allows drawing of custom text objects in QTextDocuments
Description of general rich text properties
Convenient interface for reading and writing text
Represents a table in a QTextDocument
Represents the properties of a cell in a QTextTable
Formatting information for table cells in a QTextDocument
Formatting information for tables in a QTextDocument
Convenient access to text-to-speech engines
A QAbstractTexture with a Target1D target format
A QAbstractTexture with a Target1DArray target format
A QAbstractTexture with a Target2D target format
A QAbstractTexture with a Target2DArray target format
A QAbstractTexture with a Target2DMultisample target format
A QAbstractTexture with a Target2DMultisampleArray target format
A QAbstractTexture with a Target3D target format
A QAbstractTexture with a TargetBuffer target format
A QAbstractTexture with a TargetCubeMap target format
A QAbstractTexture with a TargetCubeMapArray target format
Stores texture information such as the target, height, width, depth, layers, wrap, and if mipmaps are enabled
Holds content and information required to perform partial updates of a texture content
TODO
Encapsulates the necessary information to create an OpenGL texture image from an image source
Stores data representing a texture
Provides texture image data for QAbstractTextureImage
Handles the texture loading and setting the texture's properties
Default implementation of a simple unlit texture material
A QAbstractTexture with a TargetRectangle target format
Defines the wrap mode a Qt3DRender::QAbstractTexture should apply to a texture
Platform-independent way to manage threads
Manages a collection of QThreads
Convenience wrapper around QSensorFilter
Holds readings from the tilt sensor
Convenience wrapper around QSensor
Clock time functions
Widget for editing times based on the QDateTimeEdit widget
Timeline for controlling animations
Repetitive and single-shot timers
Contains parameters that describe a timer event
TODO
Identifies how a time representation relates to UTC
Movable panel that contains a set of controls
Column of tabbed widget items
Quick-access button to commands or options, usually used inside a QToolBar
Tool tips (balloon help) for any widget
Allows creation of a torus in 3D space
A toroidal mesh
A toroidal mesh
Basic touch display based input handler
Contains parameters that describe a touch event
QTransform (PyQt6.Qt3DCore)
Used to perform transforms on meshes
QTransform (PyQt6.QtGui)
Specifies 2D transformations of a coordinate system
Internationalization support for text output
This proxy transposes the source model
Default model/view implementation of a tree view
Tree view that uses a predefined tree model
Item for use with the QTreeWidget convenience class
Way to iterate over the items in a QTreeWidget instance
Contains a lightweight representation of a version number with two 8-bit segments, major and minor, either of which can be unknown
U
UDP socket
The base class of all commands stored on a QUndoStack
Group of QUndoStack objects
Stack of QUndoCommand objects
Displays the contents of a QUndoStack
TODO
TODO
Convenient interface for working with URLs
Way to manipulate a key-value pairs in a URL's query
Converts between a MIME type and a Uniform Type Identifier (UTI) format
Stores a Universally Unique Identifier (UUID)
V
Validation of input text
QValue3DAxis (PyQt6.QtDataVisualization)
Manipulates an axis of a graph
QValue3DAxis (PyQt6.QtGraphs)
Manipulates an axis of a graph
QValue3DAxisFormatter (PyQt6.QtDataVisualization)
Base class for value axis formatters
QValue3DAxisFormatter (PyQt6.QtGraphs)
Base class for 3D value axis formatters
QValueAxis (PyQt6.QtCharts)
Adds values to a chart's axes
QValueAxis (PyQt6.QtGraphs)
Adds values to a graph's axes
Acts like a union for the most common Qt data types
Base class for animations
Vertical model mapper for bar series
Lines up widgets vertically
Vertical model mapper for box plot series
Vertical model mapper for a candlestick series
Represents a vector or vertex in 2D space
Represents a vector or vertex in 3D space
Represents a vector or vertex in 4D space
Contains a version number with an arbitrary number of segments
A class implementing vertex-blend morphing animation
TODO
Represents a frame of video data
Specifies the stream format of a video presentation surface
Used for providing custom video frames to QMediaRecorder or a video output through QMediaCaptureSession
Represents a generic sink for video data
Widget which presents video produced by a media object
A viewport on the Qt3D Scene
Represents a particular voice
Vertical model mapper for pie series
TODO
Represents a native Vulkan instance, enabling Vulkan rendering onto a QSurface
TODO
Vertical model mapper for line, spline, and scatter series
W
Condition variable for synchronizing threads
FrameGraphNode used to wait for a fence in the graphics command stream to become signaled
Exposes QObjects to remote HTML clients
Communication channel between the C++ QWebChannel server and a HTML/JS client
Information about a certificate error
QWebEngineClientCertificateSelection
QWebEngineClientCertSelection class wraps a client certificate selection
QWebEngineClientCertificateStore
In-memory store for client certificates
Object to customize User-Agent Client Hints used by a profile
Request for populating or extending a context menu with actions
Access to Chromium's cookies
A request for populating a dialog with available sources for screen capturing
Information about a download
QWebEngineFileSystemAccessRequest
Enables accepting or rejecting requests for local file system access from JavaScript applications
Encapsulates the result of a string search on a page
Gives information about and control over a page frame
Enables accepting or rejecting requests for entering and exiting the fullscreen mode
TODO
Represents the history of a web engine page
Represents one item in the history of a web engine page
A data model that represents the history of a web engine page
Holds a request to be sent with WebEngine
A utility type for the WebEngineView::loadingChanged signal
A utility type for the QWebEnginePage::navigationRequested signal
A utility type for the QWebEnginePage::newWindowRequested() signal
Encapsulates the data of an HTML5 web notification
Object to view and edit web documents
A QWebEnginePermission is an object used to access and modify the state of a single permission that's been granted or denied to a specific origin URL
Web engine profile shared by multiple pages
Way to construct QWebEngineProfile
TODO
Enables accepting or rejecting requests for larger persistent storage than the application's current allocation in File System API
QWebEngineRegisterProtocolHandlerRequest
Enables accepting or rejecting requests from the registerProtocolHandler API
Encapsulates a JavaScript program
Represents a collection of user scripts
Object to store the settings used by QWebEnginePage
Information about URL requests
QWebEngineUrlRequestInterceptor
Abstract base class for URL interception
Represents a custom URL request
Configures a custom URL scheme
Base class for handling custom URL schemes
Widget that is used to view and edit web documents
TODO
Encapsulates the data of a WebAuth UX request
Implements a TCP socket that talks the WebSocket protocol
Authenticator object for Cross Origin Requests (CORS)
Collects options for the WebSocket handshake
TODO
Implements a WebSocket-based server
Simple description of any widget, i.e. answering the question "What's This?"
Event that can be used to handle hyperlinks in a "What's This?" text
QWheelEvent (PyQt6.Qt3DInput)
Contains parameters that describe a mouse wheel event
QWheelEvent (PyQt6.QtGui)
Contains parameters that describe a wheel event
The base class of all user interface objects
Extends QAction by an interface for inserting custom widgets into action based containers, such as toolbars
Layout item that represents a widget
Represents a window in the underlying windowing system
This class is used for capturing a window
The window state before a window state change
Support for the Windows Wait functions
Framework for wizards
The base class for wizard pages
TODO
Convenience class that simplifies locking and unlocking read-write locks for write access
X
Represents a single XML attribute
Represents a vector of QXmlStreamAttribute
Represents a DTD entity declaration
Entity resolver for a QXmlStreamReader
QXmlStreamNamespaceDeclaration
Represents a namespace declaration
Represents a DTD notation declaration
Fast parser for reading well-formed XML via a simple streaming API
XML writer with a simple streaming API
Legend marker for a line, spline, or scatter series
Model mapper for line, spline, and scatter series
QXYSeries (PyQt6.QtCharts)
Base class for line, spline, and scatter series
QXYSeries (PyQt6.QtGraphs)
Parent class for all x & y series classes
Y
TODO