Annotated Class List
Qt classes with brief descriptions:
An abstract base class for Qt3D animations | |
The base class for types providing key frame animation data | |
The base class for types providing animation playback capabilities | |
The base class for types used to construct animation blend trees | |
Performs an additive blend of two animation clips based on an additive factor | |
Provides key-frame animation capabilities to Qt 3D | |
A controller class for animations | |
A class grouping animations together | |
Component providing animation playback capabilities of a tree of blend nodes | |
Component providing simple animation playback capabilities | |
A class implementing simple keyframe animation to a QTransform | |
Performs a linear interpolation of two animation clips based on a normalized factor | |
A class implementing blend-shape morphing animation | |
A class providing morph targets to blend-shape animation | |
A class implementing vertex-blend morphing animation | |
The base class for aspects that provide a vertical slice of behavior | |
Responsible for handling all the QAbstractAspect subclasses that have been registered with the scene | |
Used to notify when a component is added to an entity | |
Used to notify when a component is removed from an entity | |
Used to notify when a dynamic property value is updated | |
Used to notify when a node is created | |
The base class for all NodeCreated QSceneChange events | |
Used to notify when a node is destroyed | |
Used to notify when a node is added to a property | |
Used to notify when a node is removed from a property | |
Used to notify when a property value is updated | |
The base class for all PropertyUpdated QSceneChange events | |
Used to notify when a value is added to a property | |
The base class for all PropertyValueAdded QSceneChange events | |
Used to notify when a value is added to a property | |
The base class for all PropertyValueRemoved QSceneChange events | |
Base class for changes that can be sent and received by Qt3D's change notification system | |
The base class for all static PropertyUpdated QSceneChange events | |
The base class for all static PropertyValueAdded QSceneChange events | |
The base class for all static PropertyValueRemoved QSceneChange events | |
Base class for jobs executed in an aspect | |
Base class for all Qt3D backend nodes | |
Creates and maps backend nodes to their respective frontend nodes | |
Base class of scene nodes that can be aggregated by Qt3DCore::QEntity instances as a component | |
Qt3DCore::QEntity is a Qt3DCore::QNode subclass that can aggregate several Qt3DCore::QComponent instances that will specify its behavior | |
The base class of all Qt3D node classes used to build a Qt3D scene | |
Uniquely identifies a QNode | |
Used to perform transforms on meshes | |
Allows creation of a 3D extruded text in 3D space | |
A 3D extruded Text mesh | |
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 | |
Allows controlling the scene camera from the first person perspective | |
Default FrameGraph implementation of a forward renderer | |
Material that implements the Gooch shading model, popular in CAD and CAM applications | |
Default implementation of PBR lighting | |
Default implementation of the phong lighting effect | |
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 | |
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 | |
Allows controlling the scene camera along orbital path | |
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 | |
Qt3DExtras::QSkyboxEntity is a convenience Qt3DCore::QEntity subclass that can be used to insert a skybox in a 3D scene | |
Default implementation of PBR lighting, environment maps and bump effect where the components are read from texture maps (including normal maps) | |
Default implementation of a simple unlit texture material | |
Allows creation of a cone in 3D space | |
A conical mesh | |
Allows creation of a cuboid in 3D space | |
A cuboid mesh | |
Allows creation of a cylinder in 3D space | |
A cylindrical mesh | |
Allows creation of a plane in 3D space | |
A square planar mesh | |
Allows creation of a sphere in 3D space | |
A spherical mesh | |
Allows creation of a torus in 3D space | |
A toroidal mesh | |
The base class for the Action Input and all Aggregate Action Inputs | |
QAbstractActionInput is the base class for all Axis Input | |
The base class used by Qt3d to interact with arbitrary input devices | |
Links a set of QAbstractActionInput that trigger the same event | |
Stores Device and Buttons used to trigger an input event | |
An axis input controlled by an analog input The axis value is controlled like a traditional analog input such as a joystick | |
Stores QAbstractAxisInputs used to trigger an input event | |
Processes velocity or acceleration data from a QAxis | |
Stores settings for the specified list of Axis | |
An axis input controlled by buttons The axis value is controlled by buttons rather than a traditional analog input such as a joystick | |
Responsible for creating physical devices and handling associated jobs | |
Represents a set of QAbstractActionInput's that must be triggerd at once | |
Represents a set of QAbstractActionInput's that must be triggerd one after the other | |
Holds the pointer to an input event source object | |
In charge of dispatching keyboard events to attached QQKeyboardHandler objects | |
Provides keyboard event notification | |
Event type send by KeyBoardHandler | |
Allows the user to define a set of actions that they wish to use within an application | |
Delegates mouse events to the attached MouseHandler objects | |
Qt3DCore::QMouseEvent contains parameters that describe a mouse event | |
Contains parameters that describe a mouse wheel event | |
Provides a means of being notified about mouse events when attached to a QMouseDevice instance | |
Provides a way to have a synchronous function executed each frame | |
Responsible for handling frame synchronization jobs | |
Provides a generic way of loading various 3D assets format into a Qt3D scene | |
Environment for the QAspectEngine and a method for instantiating QML components | |
This class enables rendering qml into a texture, which then can be used as a part of 3D scene | |
Exchanges buffer data between GPU and CPU | |
Class to allow for selection of camera to be used | |
Class to clear buffers | |
FrameGraph node to issue work for the compute shader on GPU | |
Base class of all FrameGraph configuration nodes | |
A base class for changes in the FrameGraphNode | |
Enable frustum culling for the FrameGraph | |
Controls layers Drawn in a frame graph branch | |
Class to emplace a memory barrier | |
When a Qt3DRender::QNoDraw node is present in a FrameGraph branch, this prevents the renderer from rendering any primitive | |
Frame graph node for render capture | |
Receives the result of render capture request | |
Provides storage for vectors of Filter Keys and Parameters | |
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 | |
Provides a way of specifying a render target | |
Provides storage for the sort types to be used | |
A QFrameGraphNode used to select QTechniques to use | |
A viewport on the Qt3D Scene | |
Abstract base class for all functors | |
Defines a view point through which the scene will be rendered | |
Qt3DRender::QCameraLens specifies the projection matrix that will be used to define a Camera for a 3D scene | |
QComponent to issue work for the compute shader on GPU | |
Way of filtering which entities will be rendered | |
Way of controlling the complexity of rendered entities based on their size on the screen | |
Simple spherical volume, defined by it's center and radius | |
Provides a way of enabling child entities based on distance or screen size | |
Specifies how entity picking is handled | |
Holds settings related to rendering process and host the active FrameGraph | |
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... ) | |
Defines an attribute and how data should be read from a QBuffer | |
Provides a data store for raw data to later be used as vertices or uniforms | |
Provides a mechanism to generate buffer data from a job | |
Encapsulates geometry | |
Encapsulates geometry rendering | |
A custom mesh loader | |
Provides the facility to load an existing Scene | |
Encapsulate a QAbstractLight object in a Qt 3D scene | |
Encapsulate a Directional Light object in a Qt 3D scene | |
Encapsulate an environment light object in a Qt 3D scene | |
Encapsulate a Point Light object in a Qt 3D scene | |
Encapsulate a Spot Light object in a Qt 3D scene | |
Base class for effects in a Qt 3D scene | |
Storage for filter keys and their values | |
Identifies the API required for the attached QTechnique | |
Provides an abstract class that should be the base of all material component classes in a scene | |
Provides storage for a name and value pair. This maps to a shader uniform | |
Encapsulates a Render Pass | |
Provides a way of specifying values of a Uniform Block or a shader structure | |
Encapsulates a Shader Program | |
Encapsulates a Technique | |
Instantiates a component that can be used to interact with a QEntity by a process known as picking | |
Holds information when an object is picked | |
Holds information when a triangle is picked | |
Enable alpha-to-coverage multisampling mode | |
Specify alpha reference test | |
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) | |
Enables an additional OpenGL clipping plane that can be in shaders using gl_ClipDistance | |
Allows specifying which color components should be written to the currently bound frame buffer | |
Specifies whether front or back face culling is enabled | |
Tests the fragment shader's depth value against the depth of a sample being written to | |
Enable dithering | |
Defines front and back facing polygons | |
Enable multisample antialiasing | |
Disable depth write | |
Specifies the size of rasterized points. May either be set statically or by shader programs | |
Sets the scale and steps to calculate depth values for polygon offsets | |
An abstract base class for all render states | |
Discards fragments that fall outside of a certain rectangular portion of the screen | |
Enables seamless cubemap texture filtering | |
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 | |
A base class to be used to provide textures | |
Encapsulates the necessary information to create an OpenGL texture image | |
A QAbstractTextureImage that can be written through a QPainter | |
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 | |
Handles the texture loading and setting the texture's properties | |
A QAbstractTexture with a TargetRectangle target format | |
Stores texture information such as the target, height, width, depth, layers, wrap, and if mipmaps are enabled | |
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 | |
Defines the wrap mode a Qt3DRender::QAbstractTexture should apply to a texture | |
The base of all animations | |
Abstract base class for groups of animations | |
Parallel group of animations | |
Pause for QSequentialAnimationGroup | |
Animates Qt properties | |
Sequential group of animations | |
Base class for animations | |
Conversions between text encodings | |
State-based decoder | |
State-based encoder | |
Helper data type for QFlags | |
Type-safe way of storing OR-combinations of enum values | |
Used to implement a global static object | |
Information about the Qt library | |
Additional information about a log message | |
Generates log messages | |
Information about the operating system version | |
Information about the system | |
QIODevice interface for a QByteArray | |
Serialization of binary data to a QIODevice | |
Output stream for debugging information | |
Convenience class for custom QDebug operators | |
Access to directory structures and their contents | |
Iterator for directory entrylists | |
Interface for reading from and writing to files | |
Interface for reading from and writing to open files | |
System-independent file information | |
Convenient way of selecting file variants | |
Interface for monitoring files and directories for modifications | |
The base interface class of all I/O devices in Qt | |
Locking between processes using a file | |
Represents a category, or 'area' in the logging infrastructure | |
Used to start external programs and to communicate with them | |
Holds the environment variables that can be passed to a program | |
Interface for reading directly from resources | |
Interface for safely writing to files | |
Persistent platform-independent application settings | |
Methods for accessing standard paths | |
Provides information about currently mounted storage and drives | |
Creates a unique directory for temporary use | |
I/O device that operates on temporary files | |
Convenient interface for reading and writing text | |
Convenient interface for working with URLs | |
Way to manipulate a key-value pairs in a URL's query | |
The abstract interface for item model classes | |
Abstract model that can be subclassed to create one-dimensional list models | |
Abstract model that can be subclassed to create table models | |
Used to locate data in a data model | |
Used to locate data in a data model | |
Base class for proxy item models that can do sorting, filtering or other data processing tasks | |
Proxies its source model unmodified | |
Manages information about selected items in a model | |
Keeps track of a view's selected items | |
Manages information about a range of selected items in a model | |
Support for sorting and filtering data passed between another model and a view | |
Model that supplies strings to views | |
Encapsulates a JSON array | |
Way to read and write JSON documents | |
Used to report errors during JSON parsing | |
Encapsulates a JSON object | |
Encapsulates a value in JSON | |
Interface to manage Qt's event queue | |
Interface for receiving native events, such as MSG or XCB event structs | |
Timer events for objects | |
Event loop for Qt applications without UI | |
Contains event parameters for child object events | |
Contains event parameters for dynamic property change events | |
The base class of all event classes. Event objects contain event parameters | |
Contains parameters that describe a timer event | |
Marks a deadline in the future | |
Fast way to calculate elapsed times | |
Means of entering and leaving an event loop | |
Means to quit an event loop when it is no longer needed | |
Additional information about a class | |
Meta-data about an enumerator | |
Meta-data about a member function | |
Meta-data about a property | |
Manages named types in the meta-object system | |
Container for data that records information about its MIME type | |
The base class of all Qt objects | |
Exception-safe wrapper around QObject::blockSignals() | |
Watches the lifetime of multiple QObjects | |
Internal helper class for marshalling arguments | |
Internal helper class for marshalling arguments | |
Contains meta-information about Qt objects | |
Template class that provides guarded pointers to QObject | |
Access to a shared memory segment | |
Bundles signals from identifiable senders | |
Support for monitoring activity on a file descriptor | |
General counting system semaphore | |
Repetitive and single-shot timers | |
Internationalization support for text output | |
Iterable interface for an associative container in a QVariant | |
Iterable interface for a container in a QVariant | |
Acts like a union for the most common Qt data types | |
Support for the Windows Wait functions | |
Maintains a database of MIME types | |
Describes types of file or data, represented by a MIME type string | |
Loads shared libraries at runtime | |
Struct containing a reference to a static plugin instance together with its meta data | |
Loads a plugin at run-time | |
Stores a Universally Unique Identifier (UUID) | |
The base class of states of a QStateMachine | |
The base class of transitions between QAbstractState objects | |
QObject-specific transition for Qt events | |
Final state | |
Means of returning to a previously active substate | |
Transition based on a Qt signal | |
General-purpose state for QStateMachine | |
Hierarchical finite state machine | |
Platform-independent atomic operations on int | |
Platform-independent atomic operations on integers | |
Template class that provides platform-independent atomic operations on pointers | |
Base class for exceptions that can transferred across threads | |
UnhandledException class represents an unhandled exception in a worker thread | |
Represents the result of an asynchronous computation | |
Convenience class that simplifies QFuture synchronization | |
Allows monitoring a QFuture using signals and slots | |
Access serialization between threads | |
Convenience class that simplifies locking and unlocking mutexes | |
Convenience class that simplifies locking and unlocking read-write locks for read access | |
Read-write locking | |
Convenience class that simplifies locking and unlocking read-write locks for write access | |
The base class for all runnable objects | |
General counting semaphore | |
Platform-independent way to manage threads | |
Manages a collection of QThreads | |
Per-thread data storage | |
Condition variable for synchronizing threads | |
Array of bits | |
Array of bytes | |
List of byte arrays | |
Holds a sequence of bytes that can be quickly matched in a byte array | |
Compile-time version of QByteArrayMatcher | |
Template class that provides a cache | |
16-bit Unicode character | |
8-bit ASCII/Latin-1 character | |
Compares strings according to a localized collation algorithm | |
Can be used to speed up string collation | |
Defines a possible command-line option | |
Means for handling the command line options | |
Template class that provides a contiguous cache | |
Way to generate cryptographic hashes | |
Date functions | |
Date and time functions | |
Clock time functions | |
Easing curves for controlling animation | |
Template class that provides a hash-table-based dictionary | |
Convenience QHash subclass that provides multi-valued hashes | |
Two-dimensional vector using integer precision | |
Two-dimensional vector using floating point precision | |
Template class that provides linked lists | |
Template class that provides lists | |
Converts between numbers and their string representations in various languages | |
Template class that provides a red-black-tree-based dictionary | |
Convenience QMap subclass that provides multi-valued maps | |
Defines the four margins of a rectangle | |
Defines the four margins of a rectangle | |
Way to generate hash-based message authentication codes | |
Template class that stores a pair of items | |
Defines a point in the plane using integer precision | |
Defines a point in the plane using floating point precision | |
Generic container that provides a queue | |
Defines a rectangle in the plane using integer precision | |
Defines a rectangle in the plane using floating point precision | |
Pattern matching using regular expressions | |
Pattern matching using regular expressions | |
The results of a matching a QRegularExpression against a string | |
Iterator on the results of a global match of a QRegularExpression object against a string | |
Stores a pointer to a dynamically allocated array of objects, and deletes it upon destruction | |
Stores a pointer to a dynamically allocated object, and deletes it upon destruction | |
Resets a variable to its previous value on destruction | |
Java-style non-const iterator for QSet | |
Template class that provides a hash-table-based set | |
Represents a pointer to an explicitly shared object | |
Base class for shared data objects | |
Represents a pointer to an implicitly shared object | |
A base class that allows obtaining a QSharedPointer for an object already managed by a shared pointer | |
Holds a strong reference to a shared pointer | |
Holds a weak reference to a shared pointer | |
Defines the size of a two-dimensional object using integer point precision | |
Defines the size of a two-dimensional object using floating point precision | |
Template class that provides a stack | |
Thin wrapper around an US-ASCII/Latin-1 encoded string literal | |
Unicode character string | |
Thin wrapper around QString substrings | |
List of strings | |
Holds a sequence of characters that can be quickly matched in a Unicode string | |
Way of finding Unicode text boundaries in a string | |
Timeline for controlling animations | |
Converts between UTC and local time in a specific time zone | |
Low-level variable-length array | |
Template class that provides a dynamic array | |
Contains a version number with an arbitrary number of segments | |
Represents a single XML attribute | |
Represents a vector of QXmlStreamAttribute | |
Represents a DTD entity declaration | |
Entity resolver for a QXmlStreamReader | |
Represents a namespace declaration | |
Represents a DTD notation declaration | |
Fast parser for reading well-formed XML via a simple streaming API | |
XML writer with a simple streaming API | |
The base class of 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 | |
Allows slots to determine the D-Bus context of the calls | |
Represents an error received from the D-Bus bus or from remote applications found in the bus | |
Enables the programmer to identify the OBJECT_PATH type provided by the D-Bus typesystem | |
Enables the programmer to identify the SIGNATURE type provided by the D-Bus typesystem | |
Enables the programmer to identify the variant type provided by the D-Bus typesystem | |
Proxy for interfaces on remote objects | |
Represents one message sent or received over the D-Bus bus | |
Refers to one pending asynchronous call | |
Convenient way for waiting for asynchronous replies | |
Contains the reply to an asynchronous method call | |
Stores the reply for a method call to a remote object | |
Peer-to-peer communication between processes on the same computer | |
Allows the user to watch for a bus service change | |
Holds one Unix file descriptor | |
Used to handle several DBus paths with one class | |
Enums and static functions related to accessibility | |
Implements support for invocable actions in the interface | |
Implements support for objects with editable text | |
The base class for accessibility notifications | |
Defines an interface that exposes information about accessible objects | |
Notfies the accessibility framework that the state of an object has changed | |
Implements support for the IAccessibleTable2 Cell interface | |
Implements support for the IAccessibleTable2 interface | |
Signifies a change in a table, list, or tree where cells are added or removed. If the change affected a number of rows, firstColumn and lastColumn will return -1. Likewise for columns, the row functions may return -1 | |
Notifies of cursor movements | |
Notifies of text being inserted | |
Implements support for text handling | |
Notifies of text being deleted | |
Signals a change in the text selection of an object | |
Notifies about text changes. This is for accessibles that support editable text such as line edits. This event occurs for example when a portion of selected text gets replaced by pasting a new text or in override mode of editors | |
Describes a change in value for an accessible object | |
Implements support for objects that manipulate a value | |
Implements parts of the QAccessibleInterface for QObjects | |
Abstract base class for plugins provinding accessibility information for user interface elements | |
Monochrome (1-bit depth) pixmaps | |
Scalable icons in different modes and states | |
Abstract base class for QIcon renderers | |
Abstract base for custom QIconEngine plugins | |
Hardware-independent image representation that allows direct access to the pixel data, and can be used as a paint device | |
Defines the common image I/O interface for all image formats in Qt | |
Defines an interface for writing an image format plugin | |
Format independent interface for reading images from files or other devices | |
Format independent interface for writing images to files or other devices | |
Convenience class for playing movies with QImageReader | |
Paint device that records and replays QPainter commands | |
Off-screen image representation that can be used as a paint device | |
Application-wide cache for pixmaps | |
Item for use with the QStandardItemModel class | |
Generic model for storing custom data | |
Access to the window system clipboard | |
Mouse cursor with an arbitrary shape | |
Support for MIME-based drag and drop data transfer | |
Event that is generated when a QAction is added, removed, or changed | |
Contains parameters that describe a close event | |
Contains parameters that describe a context menu event | |
Event which is sent to a widget when a drag and drop action enters it | |
Event that is sent to a widget when a drag and drop action leaves it | |
Event which is sent while a drag and drop action is in progress | |
Event which is sent when a drag and drop action is completed | |
Contains parameters that describe an enter event | |
Contains event parameters for expose events | |
Event that will be sent when there is a request to open a file or a URL | |
Contains event parameters for widget focus events | |
Event that is used to request helpful information about a particular point in a widget | |
Event which is sent after a widget is hidden | |
Contains parameters that describe a mouse event | |
Indicates that a main icon drag has begun | |
The base class for events that describe user input | |
Parameters for input method events | |
Event sent by the input context to input objects | |
Describes a key event | |
Contains parameters that describe a mouse event | |
Contains event parameters for move events | |
Contains parameters that describe a gesture event | |
Contains event parameters for paint events | |
Used to notify about native platform surface events | |
Identifies a unique object, such as a tagged token or stylus, which is used with a pointing device | |
Contains event parameters for resize events | |
Sent when scrolling | |
Sent in preparation of scrolling | |
Event which is generated when the user presses a key combination | |
Event that is sent when a widget is shown | |
Event that is used to show messages in a status bar | |
Contains parameters that describe a Tablet event | |
Contains parameters that describe a touch event | |
Event that can be used to handle hyperlinks in a "What's This?" text | |
Contains parameters that describe a wheel event | |
The window state before a window state change | |
Abstract base class for plugins | |
Creates plugin drivers | |
Manages the GUI application's control flow and main settings | |
Access to the active text input method | |
Encapsulates a key sequence as used by shortcuts | |
Represents an offscreen surface in the underlying platform | |
Represents a native OpenGL context, enabling OpenGL rendering on a QSurface | |
Represents a group of contexts sharing OpenGL resources | |
Represents the version and if applicable the profile of an OpenGL context | |
Convenience subclass of QWindow to perform OpenGL painting | |
Convenience subclass of QWindow that is also a QPaintDevice | |
Contains color groups for each widget state | |
Class for describing different pixel layouts in graphics buffers | |
Convenience class for using QPainter on a QWindow | |
Used to query screen properties | |
Access to the session manager | |
Contains platform specific hints and settings | |
Abstraction of renderable surfaces in Qt | |
Represents the format of a QSurface | |
Describes the device from which touch events originate | |
Represents a window in the underlying windowing system | |
Template class that represents a NxM transformation matrix with N columns and M rows | |
Represents a 4x4 transformation matrix in 3D space | |
Represents a quaternion consisting of a vector and scalar | |
Represents a vector or vertex in 2D space | |
Represents a vector or vertex in 3D space | |
Represents a vector or vertex in 4D space | |
Functions for creating and managing OpenGL buffer objects | |
Enables logging of OpenGL debugging messages | |
Wraps an OpenGL debug message | |
Cross-platform access to the OpenGL ES 3.0 and 3.1 API | |
Encapsulates an OpenGL framebuffer object | |
Specifies the format of an OpenGL framebuffer object | |
Cross-platform access to the OpenGL ES 2.0 API | |
All functions for OpenGL 1.0 specification | |
All functions for OpenGL 1.1 specification | |
All functions for OpenGL 1.2 specification | |
All functions for OpenGL 1.3 specification | |
All functions for OpenGL 1.4 specification | |
All functions for OpenGL 1.5 specification | |
All functions for OpenGL 2.0 specification | |
All functions for OpenGL 2.1 specification | |
All functions for OpenGL 3.0 specification | |
All functions for OpenGL 3.1 specification | |
All functions for OpenGL 3.2 compatibility profile | |
All functions for OpenGL 3.2 core profile | |
All functions for OpenGL 3.3 compatibility profile | |
All functions for OpenGL 3.3 core profile | |
All functions for OpenGL 4.0 compatibility profile | |
All functions for OpenGL 4.0 core profile | |
All functions for OpenGL 4.1 compatibility profile | |
All functions for OpenGL 4.1 core profile | |
All functions for OpenGL 4.2 compatibility profile | |
All functions for OpenGL 4.2 core profile | |
All functions for OpenGL 4.3 compatibility profile | |
All functions for OpenGL 4.3 core profile | |
All functions for OpenGL 4.4 compatibility profile | |
All functions for OpenGL 4.4 core profile | |
All functions for OpenGL 4.5 compatibility profile | |
All functions for OpenGL 4.5 core profile | |
All functions for OpenGL ES 2 | |
Enables painting to an OpenGL context using QPainter | |
Describes the pixel storage modes that affect the unpacking of pixels during texture upload | |
Allows OpenGL shaders to be compiled | |
Allows OpenGL shader programs to be linked and used | |
Encapsulates an OpenGL texture object | |
Convenient way to draw textured quads via OpenGL | |
Wraps a sequence of OpenGL timer query objects | |
Wraps an OpenGL timer query object | |
The base class of a family of classes that expose all functions for each OpenGL version and profile | |
Wraps an OpenGL Vertex Array Object | |
Drawing area for QWindow | |
Defines the fill pattern of shapes drawn by QPainter | |
Used in combination with QBrush to specify a conical gradient brush | |
Used in combination with QBrush to specify gradient fills | |
Used in combination with QBrush to specify a linear gradient brush | |
Used in combination with QBrush to specify a radial gradient brush | |
Colors based on RGB, HSV or CMYK values | |
Represents a paintdevice that supports multiple pages | |
Describes the size, orientation and margins of a page | |
Describes the size and name of a defined page size | |
The base class of objects that can be painted on with QPainter | |
Abstract definition of how QPainter draws to a given device on a given platform | |
Information about the active paint engine's current state | |
All the information required to draw text in a custom paint engine | |
Enables hardware acceleration of painting operations in Qt for Embedded Linux | |
Performs low-level painting on widgets and other paint devices | |
Container for painting operations, enabling graphical shapes to be constructed and reused | |
Used to generate fillable outlines for a given painter path | |
Class to generate PDFs that can be used as a paint device | |
Defines how a QPainter should draw lines and outlines of shapes | |
Vector of points using integer precision | |
Vector of points using floating point precision | |
Specifies a clip region for a painter | |
Struct contains a 64-bit RGB color | |
Specifies 2D transformations of a coordinate system | |
Abstract base class used to implement custom layouts for QTextDocuments | |
Allows drawing of custom text objects in QTextDocuments | |
Specifies a font used for drawing text | |
Information about the fonts available in the underlying window system | |
General information about fonts | |
Font metrics information | |
Font metrics information | |
Direct access to the internal glyphs in a font | |
Used when registering fonts with the internal Qt fontdatabase | |
Access to a single physical instance of a font | |
Enables optimized drawing of text when the text and its layout is updated rarely | |
Allows you to define syntax highlighting rules, and in addition you can use the class to query a document's current formatting or user data | |
Offers an API to access and modify QTextDocuments | |
Holds formatted text | |
Represents a piece of formatted text from a QTextDocument | |
Format-independent interface for writing a QTextDocument to files or other devices | |
Formatting information for blocks of text in a QTextDocument | |
Formatting information for characters in a QTextDocument | |
Formatting information for a QTextDocument | |
Formatting information for frames in a QTextDocument | |
Formatting information for images in a QTextDocument | |
Encapsulates the different types of length used in a QTextDocument | |
Formatting information for lists in a QTextDocument | |
Formatting information for table cells in a QTextDocument | |
Formatting information for tables in a QTextDocument | |
Represents an inline object in a QAbstractTextDocumentLayout and its implementations | |
Used to lay out and render text | |
Represents a line of text inside a QTextLayout | |
Decorated list of items in a QTextDocument | |
Container for text fragments in a QTextDocument | |
Container for text blocks within a QTextDocument | |
Used to associate custom data with blocks of text | |
Holds a piece of text in a QTextDocument with a single QTextCharFormat | |
Represents a frame in a QTextDocument | |
Base class for different kinds of objects that can group parts of a QTextDocument together | |
Description of general rich text properties | |
Represents a table in a QTextDocument | |
Represents the properties of a cell in a QTextTable | |
Methods for accessing common desktop services | |
Range checking of floating-point numbers | |
Validator that ensures a string contains a valid integer within a specified range | |
Used to check a string against a regular expression | |
Used to check a string against a regular expression | |
Validation of input text | |
The interface for cache implementations | |
Cache information | |
Specifies that a host supports HTTP Strict Transport Security policy (HSTS) | |
Resembles a MIME multipart message to be sent over HTTP | |
Holds a body part to be used inside a HTTP multipart MIME message | |
Allows the application to send network requests and receive replies | |
Holds one network cookie | |
Implements a simple jar of QNetworkCookie objects | |
Very basic disk cache | |
Contains the data and headers for a request sent with QNetworkAccessManager | |
Holds a request to be sent with QNetworkAccessManager | |
Manages the network configurations provided by the system | |
Abstraction of one or more access point configurations | |
Control over the system's access points and enables session management for cases when multiple clients access the same access point | |
Authentication object | |
Stores information about a domain name record | |
Stores information about a host address record | |
Represents a DNS lookup | |
Stores information about a DNS MX record | |
Stores information about a DNS SRV record | |
Stores information about a DNS TXT record | |
IP address | |
Static functions for host name lookups | |
The data and metadata of a UDP datagram | |
Stores one IP address supported by a network interface, along with its associated netmask and broadcast address | |
Listing of the host's IP addresses and network interfaces | |
Network layer proxy | |
Fine-grained proxy selection | |
Used to query the proxy settings for a socket | |
The base functionality common to all socket types | |
Local socket based server | |
Local socket | |
SCTP-based server | |
SCTP socket | |
TCP-based server | |
TCP socket | |
UDP socket | |
Convenient API for an X509 certificate | |
API for accessing the extensions of an X509 certificate | |
Represents an SSL cryptographic cipher | |
Holds the configuration and state of an SSL connection | |
Interface for Diffie-Hellman parameters for servers | |
Represents an elliptic curve for use by elliptic-curve cipher algorithms | |
SSL error | |
Interface for private and public keys | |
Authentication data for pre shared keys (PSK) ciphersuites | |
SSL encrypted socket for both clients and servers | |
Inline class containing miscellaneous functionality for NSWindow and NSView window specific functionality | |
Inline class containing platform-specific functionality for the eglfs platform plugin that is typically used on systems running Embedded Linux or Android | |
A class encapsulating a Cocoa NSOpenGLContext | |
A class encapsulating an EGL context and display handle | |
A class encapsulating a GLXContext and related native handles | |
A class encapsulating a WGL context on Windows with desktop OpenGL (opengl32.dll) | |
Inline class containing miscellaneous functionality for Windows window specific functionality | |
Inline class containing miscellaneous functionality for xcb window specific functionality | |
Base implementation for print dialogs used to configure printers | |
Configuration dialog for the page-related options on a printer | |
Dialog for specifying the printer's configuration | |
Dialog for previewing and configuring page layouts for printer output | |
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 | |
Widget for previewing page layouts for printer output | |
Handles a connection to a database | |
Template class that provides a SQL driver factory for a specific driver type | |
The base class for SQL driver factories | |
Abstract base class for accessing specific SQL databases | |
Abstract base for custom QSqlDriver plugins | |
SQL database error information | |
Manipulates the fields in SQL database tables and views | |
Functions to manipulate and describe database indexes | |
Means of executing and manipulating SQL statements | |
Encapsulates a database record | |
Abstract interface for accessing data from specific SQL databases | |
Read-only data model for SQL result sets | |
Delegate that is used to display and edit data from a QSqlRelationalTableModel | |
Stores information about an SQL foreign key | |
Editable data model for a single database table, with foreign key support | |
Editable data model for a single database table | |
Enables introspection of signal emission | |
List of GUI events | |
Used to simulate a sequence of touch events | |
Implements the QAccessibleInterface for QWidgets | |
Dialog widget for specifying colors | |
The base class of dialog windows | |
Error message display dialog | |
Dialog that allow users to select files or directories | |
Data model for the local filesystem | |
Dialog widget for selecting a font | |
Simple convenience dialog to get a single value from the user | |
Modal dialog for informing the user or for asking the user a question and receiving an answer | |
Feedback on the progress of a slow operation | |
Framework for wizards | |
The base class for wizard pages | |
Blur effect | |
Colorize effect | |
Drop shadow effect | |
The base class for all graphics effects | |
Opacity effect | |
Represents an anchor between two items in a QGraphicsAnchorLayout | |
Layout where one can anchor widgets together in Graphics View | |
Grid layout for managing widgets in Graphics View | |
Common base for all path items | |
Ellipse item that you can add to a QGraphicsScene | |
The base class for all graphical items in a QGraphicsScene | |
Container that treats a group of items as a single item | |
Line item that you can add to a QGraphicsScene | |
Base class for all graphics items that require signals, slots and properties | |
Path item that you can add to a QGraphicsScene | |
Pixmap item that you can add to a QGraphicsScene | |
Polygon item that you can add to a QGraphicsScene | |
Rectangle item that you can add to a QGraphicsScene | |
Simple text path item that you can add to a QGraphicsScene | |
Text item that you can add to a QGraphicsScene to display formatted text | |
The base class for all layouts in Graphics View | |
Can be inherited to allow your custom items to be managed by layouts | |
Horizontal or vertical layout for managing widgets in Graphics View | |
Proxy layer for embedding a QWidget in a QGraphicsScene | |
Surface for managing a large number of 2D graphical items | |
Context menu events in the graphics view framework | |
Events for drag and drop in the graphics view framework | |
Base class for all graphics view related events | |
Events when a tooltip is requested | |
Hover events in the graphics view framework | |
Mouse events in the graphics view framework | |
Events for widget moving in the graphics view framework | |
Events for widget resizing in the graphics view framework | |
Wheel events in the graphics view framework | |
Rotation transformation around a given axis | |
Scale transformation | |
Abstract base class for building advanced transformations on QGraphicsItems | |
Widget for displaying the contents of a QGraphicsScene | |
The base class for all widget items in a QGraphicsScene | |
Used to display and edit data items from a model | |
The basic functionality for item view classes | |
Model/view implementation of a column view | |
Mapping between a section of a data model to widgets | |
File icons for the QDirModel and the QFileSystemModel classes | |
Header row or header column for item views | |
Display and editing facilities for data items from a model | |
Makes it possible to create item editor creator bases without subclassing QItemEditorCreatorBase | |
Abstract base class that must be subclassed when implementing new item editor creators | |
Widgets for editing item data in views and delegates | |
The possibility to register widgets without having to subclass QItemEditorCreatorBase | |
List or icon view onto a model | |
Item-based list widget | |
Item for use with the QListWidget item view class | |
Display and editing facilities for data items from a model | |
Default model/view implementation of a table view | |
Item-based table view with a default model | |
Item for use with the QTableWidget class | |
Way to interact with selection in a model without using model indexes and a selection model | |
Default model/view implementation of a tree view | |
Tree view that uses a predefined tree model | |
Item for use with the QTreeWidget convenience class | |
Way to iterate over the items in a QTreeWidget instance | |
Abstract user interface action that can be inserted into widgets | |
Groups actions together | |
Manages the GUI application's control flow and main settings | |
Lines up child widgets horizontally or vertically | |
Lines up widgets horizontally | |
Lines up widgets vertically | |
Access to screen information on multi-head systems | |
Manages forms of input widgets and their associated labels | |
Represents a gesture, containing properties that describe the corresponding user input | |
The description of triggered gestures | |
Describes a panning gesture made by the user | |
Describes a pinch gesture made by the user | |
Describes a swipe gesture made by the user | |
Describes a tap-and-hold (aka LongTap) gesture made by the user | |
Describes a tap gesture made by the user | |
The infrastructure for gesture recognition | |
Lays out widgets in a grid | |
The base class of geometry managers | |
Abstract item that a QLayout manipulates | |
Blank space in a layout | |
Layout item that represents a widget | |
Widget for rendering OpenGL graphics | |
Used to create keyboard shortcuts | |
Layout attribute describing horizontal and vertical resizing policy | |
Stack of widgets where only one widget is visible at a time | |
Tool tips (balloon help) for any widget | |
Simple description of any widget, i.e. answering the question "What's This?" | |
The base class of all user interface objects | |
Extends QAction by an interface for inserting custom widgets into action based containers, such as toolbars | |
Transition for key events | |
Transition for mouse events | |
Encapsulates the common Look and Feel of a GUI | |
The rules used to draw a pixmap or image split into nine segments | |
Convenience class that simplifies dynamically overriding QStyle elements | |
Abstract base class that encapsulates the look and feel of a GUI | |
Creates QStyle objects | |
Style hints that return more than basic data types | |
Style hints that return a QRegion | |
Style hints that return a QVariant | |
Stores the parameters used by QStyle functions | |
Used to describe the parameters for drawing buttons | |
Used to describe the parameter for drawing a combobox | |
Used to hold parameters that are common to all complex controls | |
Used to describe the parameters for drawing a dock widget | |
Used to describe the parameters for drawing a focus rectangle with QStyle | |
Used to describe the parameters for drawing a frame | |
Used to describe the parameters needed to draw a QGraphicsItem | |
Describes the parameters for drawing a group box | |
Used to describe the parameters for drawing a header | |
Used to describe the parameter necessary for drawing a menu item | |
Used to describe the parameters necessary for drawing a progress bar | |
Used to describe the parameters needed for drawing a rubber band | |
Used to describe the parameter for drawing a size grip | |
Used to describe the parameters needed for drawing a slider | |
Used to describe the parameters necessary for drawing a spin box | |
Used to describe the parameters for drawing a tab bar | |
Used to describe the base of a tab bar, i.e. the part that the tab bar usually overlaps with | |
Used to describe the parameters for drawing the frame around a tab widget | |
Used to describe the parameters for drawing a title bar | |
Used to describe the parameters for drawing a toolbar | |
Used to describe the parameters needed for drawing a tool box | |
Used to describe the parameters for drawing a tool button | |
Used to describe the parameters used to draw an item in a view widget | |
Convenience class for drawing QStyle elements inside a widget | |
Abstract base for custom QStyle plugins | |
Maps device independent QColors to device dependent pixel values | |
Completions based on an item model | |
Enables kinetic scrolling for any scrolling widget or graphics item | |
Stores the settings for a QScroller | |
Icon for an application in the system tray | |
Group of QUndoStack objects | |
The base class of all commands stored on a QUndoStack | |
Stack of QUndoCommand objects | |
Displays the contents of a QUndoStack | |
The abstract base class of button widgets, providing functionality common to buttons | |
Scrolling area with on-demand scroll bars | |
Integer value within a range | |
Spinbox and a line edit to display values | |
Container to organize groups of button widgets | |
Monthly based calendar widget allowing the user to select a date | |
Checkbox with a text label | |
Combined button and popup list | |
Vista style command link button | |
Widget for editing dates based on the QDateTimeEdit widget | |
Widget for editing dates and times | |
Widget for editing times based on the QDateTimeEdit widget | |
Rounded range control (like a speedometer or potentiometer) | |
Widget that presents buttons in a layout that is appropriate to the current widget style | |
Widget that can be docked inside a QMainWindow or floated as a top-level window on the desktop | |
Focus frame which can be outside of a widget's normal paintable area | |
Combobox that lets the user select a font family | |
The base class of widgets that can have a frame | |
Group box frame with a title | |
Allows to input a QKeySequence | |
Text or image display | |
Displays a number with LCD-like digits | |
One-line text editor | |
Widget for macOS that can be used to wrap arbitrary Cocoa views (i.e., NSView subclasses) and insert them into Qt hierarchies | |
Widget for macOS that provides a way to put Qt widgets into Cocoa hierarchies | |
Main application window | |
Area in which MDI windows are displayed | |
Subwindow class for QMdiArea | |
Menu widget for use in menu bars, context menus, and other popup menus | |
Horizontal menu bar | |
Implements a plain text layout for QTextDocument | |
Widget that is used to edit and display plain text | |
Horizontal or vertical progress bar | |
Command button | |
Radio button with a text label | |
Rectangle or line that can indicate a selection or a boundary | |
Scrolling view onto another widget | |
Vertical or horizontal scroll bar | |
Resize handle for resizing top-level windows | |
Vertical or horizontal slider | |
Spin box widget that takes doubles | |
Spin box widget | |
Splash screen that can be shown during application startup | |
Implements a splitter widget | |
Handle functionality for the splitter | |
Stack of widgets where only one widget is visible at a time | |
Horizontal bar suitable for presenting status information | |
Tab bar, e.g. for use in tabbed dialogs | |
Stack of tabbed widgets | |
Rich text browser with hypertext navigation | |
Widget that is used to edit and display both plain and rich text | |
Movable panel that contains a set of controls | |
Column of tabbed widget items | |
Quick-access button to commands or options, usually used inside a QToolBar | |
Represents one attribute of a QDomElement | |
Represents an XML CDATA section | |
Represents a generic string in the DOM | |
Represents an XML comment | |
Represents an XML document | |
Tree of QDomNodes which is not usually a complete QDomDocument | |
The representation of the DTD in the document tree | |
Represents one element in the DOM tree | |
Represents an XML entity | |
Represents an XML entity reference | |
Information about the features of the DOM implementation | |
Contains a collection of nodes that can be accessed by name | |
The base class for all the nodes in a DOM tree | |
List of QDomNode objects | |
Represents an XML notation | |
Represents an XML processing instruction | |
Represents text data in the parsed XML document | |
XML attributes | |
Interface to report the logical content of XML data | |
Interface to report DTD content of XML data | |
Interface to report declaration content of XML data | |
Default implementation of all the XML handler classes | |
Interface to resolve external entities contained in XML data | |
Interface to report errors in XML data | |
The input data for the QXmlReader subclasses | |
Interface to report the lexical content of XML data | |
The XML handler classes with information about the parsing position within a file | |
Helper class for XML readers which want to include namespace support | |
Used to report errors with the QXmlErrorHandler interface | |
Interface for XML readers (i.e. parsers) | |
Implementation of a simple XML parser | |
Presents data in area charts | |
Adds categories to a chart's axes | |
Places named ranges on the axis | |
Adds dates and times to a chart's axis | |
Adds a logarithmic scale to a chart's axis | |
Base class used for specialized axis classes | |
Adds values to a chart's axes | |
Presents a series of data as horizontal bars grouped by category | |
Presents a series of categorized data as a percentage of each category | |
Presents a series of data as horizontally stacked bars, with one bar per category | |
Abstract parent class for all bar series classes | |
Represents one set of bars in a bar chart | |
Horizontal model mapper for bar series | |
Vertical model mapper for bar series | |
Presents a series of data as vertical bars grouped by category | |
Presents a series of categorized data as a percentage of each category | |
Presents a series of data as vertically stacked bars, with one bar per category | |
Presents data in box-and-whiskers charts | |
Represents one item in a box-and-whiskers chart | |
Horizontal model mapper for box plot series | |
Vertical model mapper for box plot series | |
Abstract model mapper class for candlestick series | |
Presents data as candlesticks | |
Represents a single candlestick item in a candlestick chart | |
Horizontal model mapper for a candlestick series | |
Vertical model mapper for a candlestick series | |
Legend marker for an area series | |
Legend marker for a bar series | |
Legend marker for a box plot series | |
Legend marker for a candlestick series | |
Displays the legend of a chart | |
Abstract object that can be used to access markers within a legend | |
Legend marker for a pie series | |
Legend marker for a line, spline, or scatter series | |
Presents data in line charts | |
Horizontal model mapper for pie series | |
Presents data in pie charts | |
Represents a single slice in a pie series | |
Vertical model mapper for pie series | |
Base class for all Qt Chart series | |
Manages the graphical representation of the chart's series, legends, and axes | |
Standalone widget that can display charts | |
Presents data in polar charts | |
Presents data in scatter charts | |
Presents data as spline charts | |
Horizontal model mapper for line, spline, and scatter series | |
Vertical model mapper for line, spline, and scatter series | |
Base class for line, spline, and scatter series | |
Assigns an address to the Bluetooth device | |
Discovers the Bluetooth devices nearby | |
Stores information about the Bluetooth device | |
Encapsulates the details of a local QBluetooth device | |
Enables access to the local Bluetooth device | |
Uses the RFCOMM or L2cap protocol to communicate with a Bluetooth device | |
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 | |
Transfers data to another device using Object Push Profile (OPP) | |
Stores the response for a data transfer request | |
Stores information about a data transfer request | |
Generates a UUID for each Bluetooth service | |
Represents the data to be broadcast during Bluetooth Low Energy advertising | |
Represents the parameters used for Bluetooth Low Energy advertising | |
Stores information about a Bluetooth Low Energy service characteristic | |
Used to set up GATT service data | |
Used when requesting or reporting an update of the parameters of a Bluetooth LE connection | |
Access to Bluetooth Low Energy Devices | |
Stores information about the Bluetooth Low Energy descriptor | |
Used to create GATT service data | |
Represents an individual service on a Bluetooth Low Energy Device | |
Used to set up GATT service data | |
Filter for matching NDEF messages | |
NFC NDEF message | |
NFC RTD-SmartPoster | |
NFC RTD-Text | |
NFC RTD-URI | |
NFC NDEF record | |
Access to notifications for NFC events | |
Manages all interactions related to sharing files and data over NFC | |
Transfers data to remote device over NFC | |
Interface for communicating with a target device | |
Implements the NdefRecord type in QML | |
Environment for evaluating JavaScript code | |
Acts as a container for Qt/JavaScript data types | |
Java-style iterator for QJSValue | |
Allows you to control QML file loading | |
Convenient way to load an application from a single QML file | |
Encapsulates a QML component definition | |
Defines a context within a QML engine | |
Environment for instantiating QML components | |
Used to register image providers in the QML engine | |
Encapsulates a QML error | |
Evaluates JavaScript in a QML context | |
Abstract base for custom QML extension plugins | |
A class for applying a QFileSelector to QML file loading | |
Instances drive the progress of QQmlIncubators | |
Allows QML objects to be created asynchronously | |
Allows applications to expose list-like properties of QObject-derived classes to QML | |
Allows the manipulation of QQmlListProperty properties | |
Creates QNetworkAccessManager instances for a QML engine | |
Updates on the QML parser state | |
Abstracts accessing properties on objects created from QML | |
Interface for property value sources such as animations and bindings | |
Encapsulates a script and its context | |
Allows you to set key-value pairs that can be used in QML bindings | |
Convenience class for integrating OpenGL rendering using a framebuffer object (FBO) with Qt Quick | |
The most basic of all visual items in Qt Quick | |
Contains the result from QQuickItem::grabToImage() | |
Way to use the QPainter API in the QML Scene Graph | |
Mechanism for rendering the Qt Quick scenegraph onto an offscreen render target in a fully application-controlled manner | |
Access to the QTextDocument of QQuickTextEdit | |
Window for displaying a Qt Quick user interface | |
The window for displaying a graphical QML scene | |
Gives access to the scene graph nodes and rendering of a QSGEngine | |
Low-level storage for graphics primitives in the Qt Quick Scene Graph | |
Encapsulates rendering state for a shader program | |
Represents an OpenGL shader program in the renderer | |
Used as a unique type token in combination with QSGMaterial | |
Serves as a baseclass for geometry based nodes | |
Implements the clipping functionality in the scene graph | |
Used for all rendered content in the scene graph | |
The base class for all nodes in the scene graph | |
Used to change opacity of nodes | |
Implements transformations in the scene graph | |
An interface providing access to some of the graphics API specific internals of the scenegraph | |
Represents a set of custom rendering commands targeting the graphics API that is in use by the scenegraph | |
Allows low level rendering of a scene graph | |
Convenient way of rendering solid colored geometry in the scene graph | |
Provided for convenience to easily draw textured content using the QML scene graph | |
Convenience class for drawing solid filled rectangles using scenegraph | |
Template generated class used to store the state used with a QSGSimpleMateralShader | |
Convenient way of building custom OpenGL-based materials for the scene graph | |
Serves as a baseclass for dynamically changing textures, such as content that is rendered to FBO's | |
Baseclass for textures used in the scene graph | |
Convenient way of rendering textured geometry in the scene graph | |
Convenient way of rendering textured geometry in the scene graph | |
Encapsulates texture based entities in QML | |
Convenient way of rendering per-vertex colored geometry in the scene graph | |
Interface for for asynchronous control of QML image requests | |
Interface for supporting pixmaps and threaded image requests in QML | |
Interface for asynchronous image loading in QQuickAsyncImageProvider | |
Interface for loading custom textures from QML | |
Widget for displaying a Qt Quick user interface | |
Manages an operation started by an instance of QGeoCodingManager | |
Support for geocoding operations | |
Interface and convenience methods to implementers of QGeoServiceProvider plugins who want to provide support for geocoding operations | |
Represents the information relevant to the point at which two QGeoRouteSegments meet | |
Represents a route between two points | |
Manages an operation started by an instance of QGeoRoutingManager | |
Represents the parameters and restrictions which define a request for routing information | |
Represents a segment of a route | |
Support for geographic routing operations | |
Interface and convenience methods to implementers of QGeoServiceProvider plugins who want to provide access to geographic routing information | |
Aggregates access to services which provide geographical information | |
Factory class used as the plugin interface for services related to geographical information | |
Represents a set of data about a place | |
Represents generic attribute information about a place | |
Represents a category that a QPlace can be associated with | |
Represents a contact detail such as a phone number or website url | |
Serves as the base class for rich content types | |
Manages a content retrieval operation started by an instance of QPlaceManager | |
Represents the parameters of a content request | |
Manages a place details fetch operation started by an instance of QPlaceManager | |
Represents a publisher's article describing a place | |
Represents an icon | |
Manages operations which return an identifier such as saving and removal operations of places and categories | |
Represents a reference to an image | |
The interface which allows clients to access places stored in a particular backend | |
Interface for implementers of QGeoServiceProvider plugins who want to provide access to place functionality | |
Manages a place matching operation started by an instance of QPlaceManager | |
Used to find places from one manager that match those from another. It represents a set of request parameters | |
Represents a search result containing a proposed search | |
Holds rating information about a place | |
Manages an operation started by an instance of QPlaceManager and serves as a base class for more specialized replies | |
Represents a search result containing a place | |
Represents a review of a place | |
Manages a place search operation started by an instance of QPlaceManager | |
Represents the set of parameters for a search request | |
The base class for search results | |
Manages a search suggestion operation started by an instance of QPlaceManager | |
Represents a supplier of a place or content associated with a place | |
Represents an individual user | |
Represents an address of a QGeoLocation | |
Describes the parameters of an area or region to be monitored for proximity | |
Enables the detection of proximity changes for a specified set of coordinates | |
Defines a circular geographic area | |
Defines a geographical position on the surface of the Earth | |
Represents basic information about a location | |
Defines a geographic path | |
Contains information gathered on a global position, direction and velocity at a particular point in time | |
Abstract base class for the distribution of positional updates | |
Factory class used as the plugin interface for external providers of positioning data | |
Defines a rectangular geographic area | |
Contains basic information about a satellite | |
Abstract base class for the distribution of satellite information updates | |
Defines a geographic area | |
Positional information using a NMEA data source | |
Represents a collection of audio samples with a specific format and sample rate | |
Allows decoding audio | |
Interface to query audio devices and their functionality | |
Stores audio stream parameter information | |
Interface for receiving audio data from an audio input device | |
Interface for sending audio data to an audio output device | |
Allows you to monitor audio being played or recorded | |
Base class for audio backends | |
Access for QAudioInput to access the audio device provided by the plugin | |
Base class for audio backends | |
Abstract base for audio plugins | |
Method to play .wav sound files | |
Way to play low latency sound effects | |
Interface for system camera devices | |
Interface for exposure related camera settings | |
Interface for focus and zoom related camera settings | |
Information on zones used for autofocusing a camera | |
Used for the recording of media content | |
Interface for image processing related camera settings | |
General information about camera devices | |
Set of viewfinder settings | |
Access to the audio decoding functionality of a QMediaService | |
Access to the settings of a media service that performs audio encoding | |
Audio input selector media control | |
Audio output selector media control | |
Control over the audio role of a media object | |
Control for setting the capture buffer format | |
Control for setting capture destination | |
Abstract base class for classes that control still cameras or video cameras | |
Allows controlling camera exposure parameters | |
Allows controlling feedback (sounds etc) during camera operation | |
Allows controlling a camera's flash | |
Supplies control for focusing related camera parameters | |
Control interface for image capture services | |
Abstract class for controlling image processing parameters, like white balance, contrast, saturation, sharpening and denoising | |
Camera info media control | |
Abstract base class for classes that control still cameras or video cameras | |
Abstract class for controlling camera viewfinder parameters | |
Access to the viewfinder settings of a camera media service | |
Supplies control for optical and digital camera zoom | |
Access to the settings of a media service that performs image encoding | |
Allows control over probing audio data in media objects | |
Supplies a control for reporting availability of a service | |
Access to the output container format of a QMediaService | |
Access to the gapless playback related control of a QMediaService | |
Allows the setting of the Network Access Point for media related activities | |
Access to the media playing functionality of a QMediaService | |
Access to the recording functionality of a QMediaService | |
Media stream selection control | |
Allows control over probing video frames in media objects | |
Read access to the meta-data of a QMediaService's media | |
Write access to the meta-data of a QMediaService's media | |
Access to the RDS functionality of the radio in the QMediaService | |
Access to the radio tuning functionality of a QMediaService | |
Video device selector media control | |
Access to the settings of a media service that performs video encoding | |
Media control for rendering video to a QAbstractVideoSurface | |
Media control for rendering video to a window | |
Access to the resources relating to a media content | |
Allows the playing of a media source | |
List of media content to play | |
Description of a media resource | |
The base class for objects extending media objects functionality | |
Base interface for media service controls | |
Common base for multimedia objects | |
Common base class for media service implementations | |
Interface provides camera-specific information about devices supported by a camera service plug-in | |
Interface identifies the default device used by a media service plug-in | |
Interface identifies features supported by a media service plug-in | |
Interface provides an interface for QMediaService plug-ins | |
Interface identifies the devices supported by a media service plug-in | |
Interface identifies if a media service plug-in supports a media format | |
Represents a time interval with integer precision | |
Represents a set of zero or more disjoint time intervals | |
Interfaces to the RDS functionality of the system radio | |
Interface to the systems analog radio device | |
Used for the recording of audio | |
Set of audio encoder settings | |
Set of image encoder settings | |
Set of video encoder settings | |
Used for the recording of media content | |
Abstraction for planar video data | |
Abstraction for video data | |
Represents a filter that is applied to the video frames received by a VideoOutput type | |
Represents the implementation of a filter that owns all graphics and computational resources, and performs the actual filtering or calculations | |
Base class for video presentation surfaces | |
Represents a frame of video data | |
Allows you to monitor video frames being played or recorded | |
Specifies the stream format of a video presentation surface | |
Camera viewfinder widget | |
Graphics item which display video produced by a QMediaObject | |
Widget which presents video produced by a media object | |
Media control which implements a video widget | |
Allows configuring the application style | |
Access to the Qt Script environment from Qt C++ member functions | |
Interface for defining custom behavior of (a class of) Qt Script objects | |
Iterator interface for custom Qt Script objects | |
Represents a Qt Script function invocation | |
Additional information about a QScriptContext | |
Environment for evaluating Qt Script code | |
The result of a script syntax check | |
Interface to report events pertaining to QScriptEngine execution | |
Abstract base for custom QScript extension plugins | |
Encapsulates a Qt Script program | |
Acts as a handle to "interned" strings in a QScriptEngine | |
Acts as a container for the Qt Script data types | |
Java-style iterator for QScriptValue | |
QScriptEngine debugger | |
Represents one or more sensor gesture recognizers | |
Manages sensor gestures, registers and creates sensor gesture plugins | |
The pure virtual interface to sensor gesture plugins | |
The base class for a sensor gesture recognizer | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Reports on linear acceleration along the X, Y and Z axes | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Holds readings from the altimeter sensor | |
Convenience wrapper around QSensorFilter | |
Represents one reading from the ambient light sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Holds readings of the ambient temperature | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Represents one reading from a compass | |
Convenience wrapper around QSensorFilter | |
Holds distance reading in cm from the proximity sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Represents one reading from the gyroscope sensor | |
Convenience wrapper around QSensorFilter | |
Holds readings from the holster sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Holds readings from the humidity sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Holds readings from the IR proximity sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Holds readings from the Lid sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Represents one reading from the light sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Represents one reading from the magnetometer | |
Convenience wrapper around QSensorFilter | |
Represents one reading from the orientation sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Holds readings from the pressure sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Represents one reading from the proximity sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Represents one reading from the rotation sensor | |
Convenience wrapper around QSensor | |
Represents a single hardware sensor | |
Efficient callback facility for asynchronous notifications of sensor changes | |
Holds the readings from the sensor | |
Holds the specifics of an output range | |
Sensor implementation | |
Instantiates instances of QSensorBackend | |
Handles registration and creation of sensor backends | |
The pure virtual interface to sensor plugins | |
The pure virtual interface to sensor plugins | |
Convenience wrapper around QSensorFilter | |
Represents one reading from the tap sensor | |
Convenience wrapper around QSensor | |
Convenience wrapper around QSensorFilter | |
Holds readings from the tilt sensor | |
Convenience wrapper around QSensor | |
Provides functions to access serial ports | |
Provides information about existing serial ports | |
QGraphicsItem that can be used to render the contents of SVG files | |
Paint device that is used to create SVG drawings | |
Used to draw the contents of SVG files onto paint devices | |
Widget that is used to display the contents of Scalable Vector Graphics (SVG) files | |
Item for use with QHelpContentModel | |
Model that supplies content to views | |
Tree view for displaying help content model items | |
Access to contents and indices of the help engine | |
The core functionality of the help system | |
Model that supplies index keywords to views | |
List view displaying the QHelpIndexModel | |
Access to widgets reusable to integrate fulltext search as well as to index and search documentation | |
The data associated with the search result | |
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 | |
Allows you to create a factory that is able to make instances of custom extensions in Qt Designer | |
Interface for extension factories in Qt Designer | |
Interface for extension managers in Qt Designer | |
Extension management facilities for Qt Designer | |
Allows you to change the focus of Qt Designer's action editor | |
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 query and modify a form window's widget selection, and in addition modify the properties of all the form's widgets | |
Allows you to manipulate the collection of form windows in Qt Designer, and control Qt Designer's form editing actions | |
Allows you to change the focus of Qt Designer's object inspector | |
Allows you to query and manipulate the current state of Qt Designer's property editor | |
Allows you to control the contents of Qt Designer's widget box | |
Allows you to add pages to a custom multi-page container in Qt Designer's workspace | |
Allows you to manipulate a widget's dynamic properties in Qt Designer's property editor | |
Allows you to manipulate a widget's member functions which is displayed when configuring connections using Qt Designer's mode for editing signals and slots | |
Allows you to manipulate a widget's properties which is displayed in Qt Designer's property editor | |
Allows you to add custom menu entries to Qt Designer's task menu | |
Default implementation for classes that create user interfaces at run-time | |
Used to dynamically construct user interfaces from UI files at run-time | |
Allows you to include several custom widgets in one single library | |
Enables Qt Designer to access and construct custom widgets | |
Enables standalone applications to dynamically create user interfaces at run-time using the information stored in UI files or specified in plugin paths | |
Holds the reference to a surface buffer | |
Represents a client connecting to the QWaylandCompositor | |
Manages the Wayland display server | |
Represents a keyboard device | |
Represents a displayable area managed by the compositor | |
Holds the resolution and refresh rate of an output | |
Represents a pointer device | |
Qt Quick item representing a QWaylandView | |
Access to keyboard, mouse, and touch input | |
Represents a rectangular area on an output device | |
Allows to read the content of a QWaylandSurface | |
Access to a touch device | |
Represents a view of a surface on an output | |
Extension for embedded-style user interfaces | |
Simple way to identify and resize a surface | |
Qt Quick item that represents a QWaylandShellSurface | |
Common interface for surface roles specified by shell extensions | |
Extension for desktop-style user interfaces | |
Desktop-style compositor-specific features to a surface | |
Menus for an xdg surface | |
Extension for desktop-style user interfaces | |
Desktop-style compositor-specific features to an xdg surface | |
Exposes QObjects to remote HTML clients | |
Communication channel between the C++ QWebChannel server and a HTML/JS client | |
blink::ArrayBufferOrArrayBufferViewOrBlobOrDocumentOrStringOrFormData | |
blink::V8ArrayBufferOrArrayBufferViewOrBlobOrDocumentOrStringOrFormData | |
blink::HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrImageBitmap | |
blink::V8HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrBlobOrImageDataOrImageBitmap | |
blink::OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext | |
blink::V8OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext | |
blink::V8StringOrStringSequenceOrConstrainDOMStringParameters | |
mojom::internal::MediaDevicesDispatcherHost_EnumerateDevices_Params_Data | |
mojom::internal::MediaDevicesDispatcherHost_EnumerateDevices_ResponseParams_Data | |
mojom::internal::MediaDevicesDispatcherHost_SubscribeDeviceChangeNotifications_Params_Data | |
mojom::internal::MediaDevicesDispatcherHost_UnsubscribeDeviceChangeNotifications_Params_Data | |
mojom::internal::MediaDevicesListener_OnDevicesChanged_Params_Data | |
mojom::MediaDevicesDispatcherHost_EnumerateDevices_ParamsDataView | |
mojom::MediaDevicesDispatcherHost_EnumerateDevices_ResponseParamsDataView | |
mojom::MediaDevicesDispatcherHost_SubscribeDeviceChangeNotifications_ParamsDataView | |
mojom::MediaDevicesDispatcherHost_UnsubscribeDeviceChangeNotifications_ParamsDataView | |
tracing::mojom::internal::Collector_StopAndFlush_Params_Data | |
tracing::mojom::internal::Factory_CreateRecorder_Params_Data | |
tracing::mojom::internal::StartupPerformanceDataCollector_GetStartupPerformanceTimes_Params_Data | |
tracing::mojom::internal::StartupPerformanceDataCollector_SetBrowserOpenTabsTimeDelta_Params_Data | |
tracing::mojom::internal::StartupPerformanceDataCollector_SetBrowserWindowDisplayTicks_Params_Data | |
tracing::mojom::StartupPerformanceDataCollectorInterfaceBase | |
tracing::mojom::StartupPerformanceDataCollector_GetStartupPerformanceTimes_ParamsDataView | |
tracing::mojom::StartupPerformanceDataCollector_GetStartupPerformanceTimes_ResponseParamsDataView | |
tracing::mojom::StartupPerformanceDataCollector_SetBrowserMessageLoopStartTicks_ParamsDataView | |
tracing::mojom::StartupPerformanceDataCollector_SetBrowserOpenTabsTimeDelta_ParamsDataView | |
tracing::mojom::StartupPerformanceDataCollector_SetBrowserWindowDisplayTicks_ParamsDataView | |
tracing::mojom::StartupPerformanceDataCollector_SetFirstVisuallyNonEmptyLayoutTicks_ParamsDataView | |
tracing::mojom::StartupPerformanceDataCollector_SetFirstWebContentsMainFrameLoadTicks_ParamsDataView | |
tracing::mojom::StartupPerformanceDataCollector_SetServiceManagerMainEntryPointTime_ParamsDataView | |
tracing::mojom::StartupPerformanceDataCollector_SetServiceManagerProcessCreationTime_ParamsDataView | |
blink::mojom::internal::MimeRegistry_GetMimeTypeFromExtension_Params_Data | |
blink::mojom::internal::MimeRegistry_GetMimeTypeFromExtension_ResponseParams_Data | |
blink::mojom::MimeRegistry_GetMimeTypeFromExtension_ParamsDataView | |
blink::mojom::MimeRegistry_GetMimeTypeFromExtension_ResponseParamsDataView | |
blink::mojom::internal::AppBannerController_BannerPromptRequest_Params_Data | |
blink::mojom::internal::AppBannerController_BannerPromptRequest_ResponseParams_Data | |
blink::mojom::internal::AppBannerEvent_BannerAccepted_Params_Data | |
blink::mojom::internal::AppBannerEvent_BannerDismissed_Params_Data | |
blink::mojom::internal::AppBannerService_DisplayAppBanner_Params_Data | |
blink::mojom::AppBannerController_BannerPromptRequest_ParamsDataView | |
blink::mojom::AppBannerController_BannerPromptRequest_ResponseParamsDataView | |
blink::mojom::AppBannerService_DisplayAppBanner_ParamsDataView | |
blink::mojom::internal::BackgroundSyncServiceClient_Sync_Params_Data | |
blink::mojom::internal::BackgroundSyncServiceClient_Sync_ResponseParams_Data | |
blink::mojom::internal::BackgroundSyncService_GetRegistrations_Params_Data | |
blink::mojom::internal::BackgroundSyncService_GetRegistrations_ResponseParams_Data | |
blink::mojom::internal::BackgroundSyncService_Register_Params_Data | |
blink::mojom::internal::BackgroundSyncService_Register_ResponseParams_Data | |
blink::mojom::BackgroundSyncServiceClient_Sync_ParamsDataView | |
blink::mojom::BackgroundSyncServiceClient_Sync_ResponseParamsDataView | |
blink::mojom::BackgroundSyncService_GetRegistrations_ParamsDataView | |
blink::mojom::BackgroundSyncService_GetRegistrations_ResponseParamsDataView | |
blink::mojom::BackgroundSyncService_Register_ResponseParamsDataView | |
blink::mojom::internal::WebBluetoothRemoteGATTCharacteristic_Data | |
blink::mojom::internal::WebBluetoothRequestDeviceOptions_Data | |
blink::mojom::internal::WebBluetoothServiceClient_GattServerDisconnected_Params_Data | |
blink::mojom::internal::WebBluetoothServiceClient_RemoteCharacteristicValueChanged_Params_Data | |
blink::mojom::internal::WebBluetoothService_RemoteCharacteristicReadValue_Params_Data | |
blink::mojom::internal::WebBluetoothService_RemoteCharacteristicReadValue_ResponseParams_Data | |
blink::mojom::internal::WebBluetoothService_RemoteCharacteristicStartNotifications_Params_Data | |
blink::mojom::internal::WebBluetoothService_RemoteCharacteristicStopNotifications_Params_Data | |
blink::mojom::internal::WebBluetoothService_RemoteCharacteristicWriteValue_Params_Data | |
blink::mojom::internal::WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParams_Data | |
blink::mojom::internal::WebBluetoothService_RemoteServerConnect_Params_Data | |
blink::mojom::internal::WebBluetoothService_RemoteServerConnect_ResponseParams_Data | |
blink::mojom::internal::WebBluetoothService_RemoteServerDisconnect_Params_Data | |
blink::mojom::internal::WebBluetoothService_RemoteServerGetPrimaryServices_Params_Data | |
blink::mojom::internal::WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParams_Data | |
blink::mojom::internal::WebBluetoothService_RemoteServiceGetCharacteristics_Params_Data | |
blink::mojom::internal::WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParams_Data | |
blink::mojom::internal::WebBluetoothService_RequestDevice_Params_Data | |
blink::mojom::internal::WebBluetoothService_RequestDevice_ResponseParams_Data | |
blink::mojom::internal::WebBluetoothService_SetClient_Params_Data | |
blink::mojom::WebBluetoothServiceClient_GattServerDisconnected_ParamsDataView | |
blink::mojom::WebBluetoothServiceClient_RemoteCharacteristicValueChanged_ParamsDataView | |
blink::mojom::WebBluetoothService_RemoteCharacteristicReadValue_ParamsDataView | |
blink::mojom::WebBluetoothService_RemoteCharacteristicReadValue_ResponseParamsDataView | |
blink::mojom::WebBluetoothService_RemoteCharacteristicStartNotifications_ParamsDataView | |
blink::mojom::WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParamsDataView | |
blink::mojom::WebBluetoothService_RemoteCharacteristicStopNotifications_ParamsDataView | |
blink::mojom::WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParamsDataView | |
blink::mojom::WebBluetoothService_RemoteCharacteristicWriteValue_ParamsDataView | |
blink::mojom::WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParamsDataView | |
blink::mojom::WebBluetoothService_RemoteServerConnect_ParamsDataView | |
blink::mojom::WebBluetoothService_RemoteServerConnect_ResponseParamsDataView | |
blink::mojom::WebBluetoothService_RemoteServerDisconnect_ParamsDataView | |
blink::mojom::WebBluetoothService_RemoteServerGetPrimaryServices_ParamsDataView | |
blink::mojom::WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParamsDataView | |
blink::mojom::WebBluetoothService_RemoteServiceGetCharacteristics_ParamsDataView | |
blink::mojom::WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParamsDataView | |
blink::mojom::WebBluetoothService_RequestDevice_ParamsDataView | |
blink::mojom::WebBluetoothService_RequestDevice_ResponseParamsDataView | |
blink::mojom::internal::BroadcastChannelClient_OnMessage_Params_Data | |
blink::mojom::internal::BroadcastChannelProvider_ConnectToChannel_Params_Data | |
blink::mojom::BroadcastChannelClient_OnMessage_ParamsDataView | |
blink::mojom::BroadcastChannelProvider_ConnectToChannel_ParamsDataView | |
blink::mojom::internal::BudgetService_GetBudget_ResponseParams_Data | |
blink::mojom::internal::BudgetService_GetCost_ResponseParams_Data | |
blink::mojom::internal::BudgetService_Reserve_ResponseParams_Data | |
blink::mojom::BudgetService_GetBudget_ResponseParamsDataView | |
blink::mojom::internal::Hyphenation_OpenDictionary_Params_Data | |
blink::mojom::internal::Hyphenation_OpenDictionary_ResponseParams_Data | |
blink::mojom::Hyphenation_OpenDictionary_ResponseParamsDataView | |
blink::mojom::internal::MediaSessionClient_DidReceiveAction_Params_Data | |
blink::mojom::internal::MediaSessionService_DisableAction_Params_Data | |
blink::mojom::internal::MediaSessionService_EnableAction_Params_Data | |
blink::mojom::internal::MediaSessionService_SetClient_Params_Data | |
blink::mojom::internal::MediaSessionService_SetMetadata_Params_Data | |
blink::mojom::MediaSessionClient_DidReceiveAction_ParamsDataView | |
blink::mojom::MediaSessionService_DisableAction_ParamsDataView | |
blink::mojom::MediaSessionService_EnableAction_ParamsDataView | |
blink::mojom::MediaSessionService_SetMetadata_ParamsDataView | |
blink::mojom::internal::NotificationService_GetPermissionStatus_Params_Data | |
blink::mojom::internal::NotificationService_GetPermissionStatus_ResponseParams_Data | |
blink::mojom::NotificationService_GetPermissionStatus_ParamsDataView | |
blink::mojom::NotificationService_GetPermissionStatus_ResponseParamsDataView | |
blink::mojom::blink::OffscreenCanvasCompositorFrameSinkProvider | |
blink::mojom::blink::OffscreenCanvasCompositorFrameSinkProviderProxy | |
blink::mojom::internal::OffscreenCanvasSurface_GetSurfaceId_Params_Data | |
blink::mojom::internal::OffscreenCanvasSurface_GetSurfaceId_ResponseParams_Data | |
blink::mojom::internal::OffscreenCanvasSurface_Require_Params_Data | |
blink::mojom::internal::OffscreenCanvasSurface_Satisfy_Params_Data | |
blink::mojom::OffscreenCanvasCompositorFrameSinkProviderInterfaceBase | |
blink::mojom::OffscreenCanvasCompositorFrameSinkProvider_CreateCompositorFrameSink_ParamsDataView | |
blink::mojom::OffscreenCanvasSurface_GetSurfaceId_ParamsDataView | |
blink::mojom::OffscreenCanvasSurface_GetSurfaceId_ResponseParamsDataView | |
blink::mojom::OffscreenCanvasCompositorFrameSinkProviderProxy | |
blink::mojom::internal::PermissionObserver_OnPermissionStatusChange_Params_Data | |
blink::mojom::internal::PermissionService_AddPermissionObserver_Params_Data | |
blink::mojom::internal::PermissionService_HasPermission_Params_Data | |
blink::mojom::internal::PermissionService_HasPermission_ResponseParams_Data | |
blink::mojom::internal::PermissionService_RequestPermission_Params_Data | |
blink::mojom::internal::PermissionService_RequestPermission_ResponseParams_Data | |
blink::mojom::internal::PermissionService_RequestPermissions_Params_Data | |
blink::mojom::internal::PermissionService_RequestPermissions_ResponseParams_Data | |
blink::mojom::internal::PermissionService_RevokePermission_Params_Data | |
blink::mojom::internal::PermissionService_RevokePermission_ResponseParams_Data | |
blink::mojom::PermissionObserver_OnPermissionStatusChange_ParamsDataView | |
blink::mojom::PermissionService_AddPermissionObserver_ParamsDataView | |
blink::mojom::PermissionService_HasPermission_ParamsDataView | |
blink::mojom::PermissionService_HasPermission_ResponseParamsDataView | |
blink::mojom::PermissionService_RequestPermission_ParamsDataView | |
blink::mojom::PermissionService_RequestPermission_ResponseParamsDataView | |
blink::mojom::PermissionService_RequestPermissions_ParamsDataView | |
blink::mojom::PermissionService_RequestPermissions_ResponseParamsDataView | |
blink::mojom::PermissionService_RevokePermission_ParamsDataView | |
blink::mojom::PermissionService_RevokePermission_ResponseParamsDataView | |
blink::mojom::internal::PresentationConnectionCloseReason_Data | |
blink::mojom::internal::PresentationServiceClient_OnConnectionClosed_Params_Data | |
blink::mojom::internal::PresentationServiceClient_OnConnectionStateChanged_Params_Data | |
blink::mojom::internal::PresentationServiceClient_OnDefaultSessionStarted_Params_Data | |
blink::mojom::internal::PresentationServiceClient_OnReceiverConnectionAvailable_Params_Data | |
blink::mojom::internal::PresentationServiceClient_OnScreenAvailabilityNotSupported_Params_Data | |
blink::mojom::internal::PresentationServiceClient_OnScreenAvailabilityUpdated_Params_Data | |
blink::mojom::internal::PresentationServiceClient_OnSessionMessagesReceived_Params_Data | |
blink::mojom::internal::PresentationService_CloseConnection_Params_Data | |
blink::mojom::internal::PresentationService_JoinSession_Params_Data | |
blink::mojom::internal::PresentationService_JoinSession_ResponseParams_Data | |
blink::mojom::internal::PresentationService_ListenForScreenAvailability_Params_Data | |
blink::mojom::internal::PresentationService_ListenForSessionMessages_Params_Data | |
blink::mojom::internal::PresentationService_SendSessionMessage_Params_Data | |
blink::mojom::internal::PresentationService_SendSessionMessage_ResponseParams_Data | |
blink::mojom::internal::PresentationService_SetClient_Params_Data | |
blink::mojom::internal::PresentationService_SetDefaultPresentationUrls_Params_Data | |
blink::mojom::internal::PresentationService_StartSession_Params_Data | |
blink::mojom::internal::PresentationService_StartSession_ResponseParams_Data | |
blink::mojom::internal::PresentationService_StopListeningForScreenAvailability_Params_Data | |
blink::mojom::internal::PresentationService_Terminate_Params_Data | |
blink::mojom::PresentationServiceClient_OnConnectionClosed_ParamsDataView | |
blink::mojom::PresentationServiceClient_OnConnectionStateChanged_ParamsDataView | |
blink::mojom::PresentationServiceClient_OnDefaultSessionStarted_ParamsDataView | |
blink::mojom::PresentationServiceClient_OnReceiverConnectionAvailable_ParamsDataView | |
blink::mojom::PresentationServiceClient_OnScreenAvailabilityNotSupported_ParamsDataView | |
blink::mojom::PresentationServiceClient_OnScreenAvailabilityUpdated_ParamsDataView | |
blink::mojom::PresentationServiceClient_OnSessionMessagesReceived_ParamsDataView | |
blink::mojom::PresentationService_CloseConnection_ParamsDataView | |
blink::mojom::PresentationService_JoinSession_ParamsDataView | |
blink::mojom::PresentationService_JoinSession_ResponseParamsDataView | |
blink::mojom::PresentationService_ListenForScreenAvailability_ParamsDataView | |
blink::mojom::PresentationService_ListenForSessionMessages_ParamsDataView | |
blink::mojom::PresentationService_SendSessionMessage_ParamsDataView | |
blink::mojom::PresentationService_SendSessionMessage_ResponseParamsDataView | |
blink::mojom::PresentationService_SetDefaultPresentationUrls_ParamsDataView | |
blink::mojom::PresentationService_StartSession_ParamsDataView | |
blink::mojom::PresentationService_StartSession_ResponseParamsDataView | |
blink::mojom::PresentationService_StopListeningForScreenAvailability_ParamsDataView | |
blink::mojom::blink::SensitiveInputVisibilityServiceStubDispatch | |
blink::mojom::SensitiveInputVisibilityService_PasswordFieldVisibleInInsecureContext_ParamsDataView | |
blink::mojom::internal::ShapeDetection_DetectBarcodes_Params_Data | |
blink::mojom::internal::ShapeDetection_DetectBarcodes_ResponseParams_Data | |
blink::mojom::internal::ShapeDetection_DetectFaces_Params_Data | |
blink::mojom::internal::ShapeDetection_DetectFaces_ResponseParams_Data | |
blink::mojom::ShapeDetection_DetectBarcodes_ResponseParamsDataView | |
blink::mojom::ShapeDetection_DetectFaces_ResponseParamsDataView | |
blink::mojom::internal::ShareService_Share_ResponseParams_Data | |
blink::mojom::internal::WebSocketClient_OnAddChannelResponse_Params_Data | |
blink::mojom::internal::WebSocketClient_OnClosingHandshake_Params_Data | |
blink::mojom::internal::WebSocketClient_OnDataFrame_Params_Data | |
blink::mojom::internal::WebSocketClient_OnDropChannel_Params_Data | |
blink::mojom::internal::WebSocketClient_OnFailChannel_Params_Data | |
blink::mojom::internal::WebSocketClient_OnFinishOpeningHandshake_Params_Data | |
blink::mojom::internal::WebSocketClient_OnFlowControl_Params_Data | |
blink::mojom::internal::WebSocketClient_OnStartOpeningHandshake_Params_Data | |
blink::mojom::internal::WebSocket_AddChannelRequest_Params_Data | |
blink::mojom::internal::WebSocket_SendFlowControl_Params_Data | |
blink::mojom::internal::WebSocket_StartClosingHandshake_Params_Data | |
blink::mojom::WebSocketClient_OnAddChannelResponse_ParamsDataView | |
blink::mojom::WebSocketClient_OnClosingHandshake_ParamsDataView | |
blink::mojom::WebSocketClient_OnFinishOpeningHandshake_ParamsDataView | |
blink::mojom::WebSocketClient_OnStartOpeningHandshake_ParamsDataView | |
blink::mojom::WebSocket_StartClosingHandshake_ParamsDataView | |
Access to Chromium's cookies | |
Holds a request to be sent with WebEngine | |
Information about URL requests | |
Abstract base class for URL interception | |
Represents a custom URL request | |
Base class for handling custom URL schemes | |
Web engine profile shared by multiple pages | |
Enables the injection of scripts in the JavaScript engine | |
Information about a certificate error | |
Context data for populating or extending a context menu with actions | |
Information about a download | |
Enables accepting or rejecting requests for entering and exiting the fullscreen mode | |
Represents the history of a web engine page | |
Represents one item in the history of a web engine page | |
Object to view and edit web documents | |
Web engine profile shared by multiple pages | |
Encapsulates a JavaScript program | |
Represents a collection of user scripts | |
Object to store the settings used by QWebEnginePage | |
Widget that is used to view and edit web documents | |
Access to HTML 5 databases created with JavaScript | |
Convenient access to DOM elements in a QWebFrame | |
Represents a collection of web elements | |
Represents the history of a QWebPage | |
Represents one item in the history of a QWebPage | |
Interface to implement link history | |
Used to embed custom data types in web pages | |
Defines a security boundary for web sites | |
Object to store the settings used by QWebPage and QWebFrame | |
Allows Web content to be added to a GraphicsView | |
Represents a frame in a web page | |
Information about the web page content after a hit test | |
Allows the placement and control of a QWebPage's inspector. The inspector can display a page's hierarchy, its loading statistics and the current state of its individual elements. It is mostly used by web developers | |
Object to view and edit web documents | |
Widget that is used to view and edit web documents | |
Abstract base for custom 32-bit mask generators | |
Implements a TCP socket that talks the WebSocket protocol | |
Authenticator object for Cross Origin Requests (CORS) | |
Implements a WebSocket-based server | |
Provides information about the X display configuration | |
Java-style const iterator for QFuture | |
Java-style const iterator for QHash and QMultiHash | |
Java-style non-const iterator for QHash and QMultiHash | |
Java-style const iterator for QLinkedList | |
Java-style non-const iterator for QLinkedList | |
Java-style const iterator for QList and QQueue | |
Java-style non-const iterator for QList and QQueue | |
Java-style const iterator for QMap and QMultiMap | |
Java-style non-const iterator for QMap and QMultiMap | |
Java-style const iterator for QSet | |
Java-style non-const iterator for QVector and QStack | |
Java-style const iterator for QVector and QStack |