Uses of Interface
io.qt.QtObjectInterface
Package
Description
-
Uses of QtObjectInterface in io.qt
Modifier and TypeClassDescriptionclass
io.qt.MemberAccess<T extends QtObjectInterface>
This class manages member access for interface default functions.Modifier and TypeClassDescriptionclass
Supertype for generic Q_GADGET types.class
Super class of all native types provided by QtJambi.Modifier and TypeMethodDescription<Q extends QtObjectInterface,
M extends io.qt.MemberAccess<Q>>
Mstatic <T extends QtObjectInterface>
QNativePointerQNativePointer.fromArray
(T... array) static <T extends QtObjectInterface>
QNativePointerQNativePointer.fromObject
(T object) <T extends QtObjectInterface>
TIf the native pointer is of pointer type, this function returns its value matching the given valueType.<T extends QtObjectInterface>
T[]QNativePointer.objectArray
(Class<T> valueType) If the native pointer is of pointer type, this function returns its value matching the given valueType.<T extends QtObjectInterface>
TReturns the value of the native pointer matching the given valueType at the specified position.<T extends QtObjectInterface>
voidQNativePointer.setObjectAt
(long pos, T value) Sets the value of the array element atpos
to which this native pointer points.<T extends QtObjectInterface>
voidQNativePointer.setObjectValue
(T value) Sets the value of this pointer tovalue
.Modifier and TypeMethodDescription<T extends QtObjectInterface>
T[]QNativePointer.objectArray
(Class<T> valueType) If the native pointer is of pointer type, this function returns its value matching the given valueType.Modifier and TypeMethodDescriptionvoid
InternalAccess.addAllReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isThreadSafe, boolean isStatic, Collection<?> values) void
InternalAccess.addReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isThreadSafe, boolean isStatic, Object value) long
InternalAccess.checkedNativeId
(QtObjectInterface object) InternalAccess.checkedNativeIdInfo
(QtObjectInterface object) void
InternalAccess.clearReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isStatic) static <T extends QtObjectInterface>
QNativePointerQNativePointer.fromArray
(T... array) static QMetaObject.DisposedSignal
QtUtilities.getSignalOnDispose
(QtObjectInterface object) boolean
InternalAccess.hasOwnerFunction
(QtObjectInterface object) static void
QtUtilities.initializeNativeObject
(QtObjectInterface object) static void
QtUtilities.initializeNativeObject
(QtObjectInterface object, QtArgument.Stream arguments) void
InternalAccess.invalidateObject
(QtObjectInterface object) boolean
InternalAccess.isCppOwnership
(QtObjectInterface object) boolean
InternalAccess.isJavaOwnership
(QtObjectInterface object) boolean
InternalAccess.isSplitOwnership
(QtObjectInterface object) long
InternalAccess.nativeId
(QtObjectInterface object) boolean
InternalAccess.needsReferenceCounting
(QtObjectInterface object) InternalAccess.owner
(QtObjectInterface object) void
InternalAccess.putReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isThreadSafe, boolean isStatic, Object key, Object value) void
InternalAccess.registerDependentObject
(QtObjectInterface dependentObject, QtObject owner) void
InternalAccess.registerDependentObject
(QtObjectInterface dependentObject, QtObjectInterface owner) void
InternalAccess.registerDependentObject
(QtObject dependentObject, QtObjectInterface owner) void
InternalAccess.removeFromCollectionReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isStatic, Object value) void
InternalAccess.removeFromMapReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isStatic, Object value) void
InternalAccess.setCppOwnership
(QtObjectInterface object) void
InternalAccess.setDefaultOwnership
(QtObjectInterface object) void
InternalAccess.setJavaOwnership
(QtObjectInterface object) void
InternalAccess.setReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean threadSafe, boolean isStatic, Object newValue) void
InternalAccess.truncateBuffer
(QtObjectInterface owner, Buffer buffer) void
InternalAccess.unregisterDependentObject
(QtObjectInterface dependentObject, QtObject owner) void
InternalAccess.unregisterDependentObject
(QtObjectInterface dependentObject, QtObjectInterface owner) void
InternalAccess.unregisterDependentObject
(QtObject dependentObject, QtObjectInterface owner) Modifier and TypeMethodDescriptionvoid
InternalAccess.addAllReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isThreadSafe, boolean isStatic, Collection<?> values) void
InternalAccess.addReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isThreadSafe, boolean isStatic, Object value) void
InternalAccess.clearReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isStatic) void
InternalAccess.putReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isThreadSafe, boolean isStatic, Object key, Object value) void
InternalAccess.removeFromCollectionReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isStatic, Object value) void
InternalAccess.removeFromMapReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean isStatic, Object value) void
InternalAccess.setReferenceCount
(QtObjectInterface owner, Class<? extends QtObjectInterface> declaringClass, String fieldName, boolean threadSafe, boolean isStatic, Object newValue) -
Uses of QtObjectInterface in io.qt.activex
Modifier and TypeInterfaceDescriptioninterface
Abstract class that provides an API to initialize and access a COM objectinterface
Interface providing common properties of QAxObject and QAxWidgetModifier and TypeClassDescriptionclass
Static properties and signals for QAxObjectclass
Static properties and signals for QAxWidgetclass
QObject that wraps a COM objectclass
Wrapper around script codeclass
Wrapper around a script engineclass
Bridge between application objects and script codeclass
Selection dialog for registered COM componentsclass
QWidget that wraps an ActiveX control -
Uses of QtObjectInterface in io.qt.bluetooth
Modifier and TypeClassDescriptionclass
Assigns an address to the Bluetooth deviceclass
Discovers the Bluetooth devices nearbyclass
Stores information about the Bluetooth deviceclass
Encapsulates the details of a local QBluetooth deviceclass
Enables access to the local Bluetooth deviceclass
Uses the RFCOMM or L2cap protocol to communicate with a Bluetooth deviceclass
Enables you to query for Bluetooth servicesclass
Enables access to the attributes of a Bluetooth servicestatic class
Stores attributes of a Bluetooth Data Element Alternativestatic class
Stores attributes of a Bluetooth Data Element Sequenceclass
Enables connection to a Bluetooth device running a bluetooth serverclass
Generates a UUID for each Bluetooth serviceclass
Represents the data to be broadcast during Bluetooth Low Energy advertisingclass
Represents the parameters used for Bluetooth Low Energy advertisingstatic class
QLowEnergyAdvertisingParameters::AddressInfo defines the elements of a white listclass
Stores information about a Bluetooth Low Energy service characteristicclass
Used to set up GATT service dataclass
Used when requesting or reporting an update of the parameters of a Bluetooth LE connectionfinal class
Access to Bluetooth Low Energy Devicesclass
Stores information about the Bluetooth Low Energy descriptorclass
Used to create GATT service datafinal class
Represents an individual service on a Bluetooth Low Energy Deviceclass
Used to set up GATT service data -
Uses of QtObjectInterface in io.qt.charts
Modifier and TypeClassDescriptionclass
Base class used for specialized axis classesclass
Abstract parent class for all bar series classesclass
Base class for all Qt Graphs for 2D seriesclass
Legend marker for an area seriesclass
Presents data in area graphsclass
Adds categories to a graph's axesclass
Legend marker for a bar seriesclass
Model mapper for bar seriesclass
Presents data in bar graphsclass
Represents one set of bars in a bar graphclass
Legend marker for a box plot seriesclass
Java wrapper for Qt classQBoxPlotModelMapper
class
Presents data in box-and-whiskers chartsclass
Represents one item in a box-and-whiskers chartclass
Legend marker for a candlestick seriesclass
Abstract model mapper class for candlestick seriesclass
Presents data as candlesticksclass
Represents a single candlestick item in a candlestick chartclass
Places named ranges on the axisclass
Manages the graphical representation of the chart's series, legends, and axesclass
Standalone widget that can display chartsclass
Displays a color scale as one of the chart's axesclass
Adds support for DateTime values to be added to a graph's axisclass
Horizontal model mapper for bar seriesclass
Horizontal model mapper for box plot seriesclass
Horizontal model mapper for a candlestick seriesclass
Presents a series of data as horizontal bars grouped by categoryclass
Presents a series of categorized data as a percentage of each categoryclass
Presents a series of data as horizontally stacked bars, with one bar per categoryclass
Horizontal model mapper for pie seriesclass
Horizontal model mapper for line, spline, and scatter seriesfinal class
Displays the legend of a chartclass
Abstract object that can be used to access markers within a legendclass
Presents data in line graphsclass
Adds a logarithmic scale to a chart's axisclass
Presents a series of categorized data as a percentage of each categoryclass
Legend marker for a pie seriesclass
Model mapper for pie seriesclass
Presents data in pie graphsclass
Represents a single slice in a pie seriesclass
Presents data in polar chartsclass
Presents data in scatter graphsclass
Presents data in spline graphsclass
Presents a series of data as vertically stacked bars, with one bar per categoryclass
Adds values to a graph's axesclass
Vertical model mapper for bar seriesclass
Vertical model mapper for box plot seriesclass
Vertical model mapper for a candlestick seriesclass
Vertical model mapper for pie seriesclass
Vertical model mapper for line, spline, and scatter seriesclass
Legend marker for a line, spline, or scatter seriesclass
Model mapper for line, spline, and scatter seriesclass
Parent class for all x & y series classes -
Uses of QtObjectInterface in io.qt.concurrent
Modifier and TypeClassDescriptionstatic final class
Java wrapper for Qt's classQtConcurrent::ThreadEngineStarter
-
Uses of QtObjectInterface in io.qt.core
Modifier and TypeClassDescriptionfinal class
QPointer<O extends QtObjectInterface>
Java wrapper for Qt class QPointer.final class
QSharedPointer<O extends QtObjectInterface>
Java class representing Qt class QSharedPointer.final class
QWeakPointer<O extends QtObjectInterface>
Java wrapper for Qt class QWeakPointer similar toWeakReference
but also supplyingnull
when resource has been disposed.Modifier and TypeInterfaceDescriptionstatic interface
Java wrapper for Qt callableQEasingCurve::EasingFunction
interface
Java wrapper for Qt classQFactoryInterface
interface
Base class for QIODevice that provides flags describing the mode in which a device is openedstatic interface
Java wrapper for Qt callableQLoggingCategory::CategoryFilter
interface
The base class for all runnable objectsstatic interface
Java wrapper for Qt callableQSettings::ReadFunc
static interface
Java wrapper for Qt callableQSettings::WriteFunc
interface
Java wrapper for Qt callableQtMessageHandler
Modifier and TypeClassDescriptionclass
The base of all animationsclass
Interface to manage Qt's event queuestatic class
Java wrapper for Qt classQAbstractEventDispatcher::TimerInfo
static class
Java wrapper for Qt classQAbstractEventDispatcher::TimerInfoV2
class
Java wrapper for Qt classQAbstractEventDispatcherV2
class
The abstract interface for item model classesclass
Abstract model that can be subclassed to create one-dimensional list modelsclass
Base class for proxy item models that can do sorting, filtering or other data processing tasksclass
Abstract model that can be subclassed to create table modelsclass
Java wrapper for Qt classQAnimationDriver
class
Abstract base class for groups of animationsclass
QAssociativeConstIterator<Key,
T> Java-iterable wrapper for Qt's constant iterator types:final class
QAssociativeIterator<Key,
T> Java-iterable wrapper for Qt's iterator types:class
Java wrapper for Qt classQBasicMutex
class
Timer events for objectsfinal class
QBindable<T>
Java wrapper for Qt class QBindableclass
Array of bitsclass
Access Bluetooth peripheralsfinal class
QBooleanBindable is primitive-typed version of QBindable<Boolean>.final class
QBooleanProperty is primitive-typed version of QProperty<Boolean>.final class
Deprecated, for removal: This API element is subject to removal in a future version.final class
QBooleanPropertyBinding is primitive-typed version of QPropertyBinding<Boolean>.class
QBooleanPropertyData is primitive-typed version of QPropertyData<Boolean>.class
QIODevice interface for a QByteArrayclass
Array of bytesstatic class
QByteArray::FromBase64Result class holds the result of a call to QByteArray::fromBase64Encodingclass
Holds a sequence of bytes that can be quickly matched in a byte arrayclass
View on an array of bytes with a read-only subset of the QByteArray APIfinal class
QByteBindable is primitive-typed version of QBindable<Byte>.final class
QByteProperty is primitive-typed version of QProperty<Byte>.final class
Deprecated, for removal: This API element is subject to removal in a future version.Class was only meant for internal use, use aQProperty
and add a binding to the targetfinal class
QBytePropertyBinding is primitive-typed version of QPropertyBinding<Byte>.class
QBytePropertyData is primitive-typed version of QPropertyData<Byte>.class
Describes calendar systemsstatic class
Java wrapper for Qt classQCalendar::YearMonthDay
class
Access the user's calendarclass
Access the camera for taking pictures or videosclass
Used to hold an array of CBOR elementsclass
Holds the error condition found while parsing or validating a CBOR streamclass
Used to hold an associative container representable in CBORclass
Used by QCborValue to report a parsing errorclass
Simple CBOR stream decoder, operating on either a QByteArray or QIODevicestatic class
QCborStreamReader.StringResult<Container>
Java wrapper for Qt classQCborStreamReader::StringResult<QVariant>
class
Simple CBOR encoder operating on a one-way streamclass
Encapsulates a value in CBORfinal class
16-bit Unicode characterfinal class
QCharBindable is primitive-typed version of QBindable<Character>.final class
QCharProperty is primitive-typed version of QProperty<Character>.final class
Deprecated, for removal: This API element is subject to removal in a future version.Class was only meant for internal use, use aQProperty
and add a binding to the targetfinal class
QCharPropertyBinding is primitive-typed version of QPropertyBinding<Character>.class
QCharPropertyData is primitive-typed version of QPropertyData<Character>.class
Contains event parameters for child object eventsclass
Repetitive and single-shot timersclass
Compares strings according to a localized collation algorithmclass
Can be used to speed up string collationclass
Defines a possible command-line optionclass
Means for handling the command line optionsclass
Proxies multiple source models, concatenating their rowsclass
QConstSpan<T>
Java wrapper for Qt classQSpan
class
Access the user's contactsclass
Event loop for Qt applications without UIclass
Way to generate cryptographic hashesclass
Serialization of binary data to a QIODeviceclass
Date functionsclass
Date and time functionsclass
Marks a deadline in the futureclass
Output stream for debugging informationclass
Convenience class for custom QDebug operatorsclass
Access to directory structures and their contentsclass
Iterator for directory entrylistsclass
STL-style iterator for directory entriesstatic class
Java wrapper for Qt classQDirListing::DirEntry
final class
QDoubleBindable is primitive-typed version of QBindable<Double>.final class
QDoubleProperty is primitive-typed version of QProperty<Double>.final class
Deprecated, for removal: This API element is subject to removal in a future version.Class was only meant for internal use, use aQProperty
and add a binding to the targetfinal class
QDoublePropertyBinding is primitive-typed version of QPropertyBinding<Double>.class
QDoublePropertyData is primitive-typed version of QPropertyData<Double>.class
Contains event parameters for dynamic property change eventsclass
Easing curves for controlling animationclass
Fast way to calculate elapsed timesclass
The base class of all event classes.class
Means of entering and leaving an event loopclass
Means to quit an event loop when it is no longer neededclass
Interface for reading from and writing to filesclass
Interface for reading from and writing to open filesclass
OS-independent API to retrieve information about file system entriesclass
Convenient way of selecting file variantsclass
Interface for monitoring files and directories for modificationsfinal class
QFloatBindable is primitive-typed version of QBindable<Float>.final class
QFloatProperty is primitive-typed version of QProperty<Float>.final class
Deprecated, for removal: This API element is subject to removal in a future version.Class was only meant for internal use, use aQProperty
and add a binding to the targetfinal class
QFloatPropertyBinding is primitive-typed version of QPropertyBinding<Float>.class
QFloatPropertyData is primitive-typed version of QPropertyData<Float>.final class
Java wrapper for Qt callableQFunctionPointer
final class
Java wrapper for Qt class QFutureInterfaceclass
Java wrapper for Qt classQFutureInterfaceBase
final class
Allows monitoring a QFuture using signals and slotsclass
Java wrapper for Qt classQFutureWatcherBase
class
QHash<Key,
T> Java wrapper for Qt classQHash
class
Java wrapper for Qt classQHashSeed
class
Proxies its source model unmodifiedfinal class
QIntBindable is primitive-typed version of QBindable<Integer>.final class
QIntProperty is primitive-typed version of QProperty<Integer>.final class
Deprecated, for removal: This API element is subject to removal in a future version.Class was only meant for internal use, use aQProperty
and add a binding to the targetfinal class
QIntPropertyBinding is primitive-typed version of QPropertyBinding<Integer>.class
QIntPropertyData is primitive-typed version of QPropertyData<Integer>.class
The base interface class of all I/O devices in Qtclass
Manages information about selected items in a modelclass
Keeps track of a view's selected itemsclass
Manages information about a range of selected items in a modelclass
Encapsulates a JSON arrayclass
Way to read and write JSON documentsclass
Encapsulates a JSON objectclass
Used to report errors during JSON parsingclass
Encapsulates a value in JSONclass
Loads shared libraries at runtimefinal class
Information about the Qt libraryclass
Two-dimensional vector using integer precisionclass
Two-dimensional vector using floating point precisionclass
QList<T>
Java wrapper for Qt classQList
class
Converts between numbers and their string representations in various languagesclass
Access the user's locationclass
Locking between processes using a fileclass
Represents a category, or 'area' in the logging infrastructurefinal class
QLongBindable is primitive-typed version of QBindable<Long>.final class
QLongProperty is primitive-typed version of QProperty<Long>.final class
Deprecated, for removal: This API element is subject to removal in a future version.final class
QLongPropertyBinding is primitive-typed version of QPropertyBinding<Long>.class
QLongPropertyData is primitive-typed version of QPropertyData<Long>.class
QMap<Key,
T> Java wrapper for Qt classQMap
class
Defines the four margins of a rectangleclass
Defines the four margins of a rectangleclass
Way to generate hash-based message authentication codesclass
Additional information about a log messageclass
Meta-data about an enumeratorclass
Meta-data about a member functionclass
Meta-data about a propertyclass
Manages named types in the meta-object systemstatic final class
This class represents a QMetaType-registered but Java-unknown gadget type.static final class
This class represents a QMetaType-registered but Java-unknown object type.static final class
This class represents a QMetaType-registered but Java-unknown value type.class
Access the microphone for monitoring or recording soundclass
Container for data that records information about its MIME typeclass
Maintains a database of MIME typesclass
Describes types of file or data, represented by a MIME type stringclass
Used to locate data in a data modelclass
QMultiHash<Key,
T> Java wrapper for Qt classQMultiHash
class
QMultiMap<Key,
T> Java wrapper for Qt classQMultiMap
class
Access serialization between threadsclass
Convenience class that simplifies locking and unlocking mutexesclass
Holds a native key used by QSystemSemaphore and QSharedMemoryclass
The base class of all Qt objectsfinal class
QBooleanProperty is primitive-typed version of QProperty<Boolean>.final class
QByteProperty is primitive-typed version of QProperty<Byte>.final class
QCharProperty is primitive-typed version of QProperty<Character>.final class
QComputedBooleanProperty is primitive-typed version of QComputedProperty<Boolean>.final class
QComputedByteProperty is primitive-typed version of QComputedProperty<Byte>.final class
QComputedCharProperty is primitive-typed version of QComputedProperty<Character>.final class
QComputedDoubleProperty is primitive-typed version of QComputedProperty<Double>.final class
QComputedFloatProperty is primitive-typed version of QComputedProperty<Float>.final class
QComputedIntProperty is primitive-typed version of QComputedProperty<Integer>.final class
QComputedLongProperty is primitive-typed version of QComputedProperty<Long>.final class
TheQComputedProperty
class is a template class for externally computed/stored values.final class
QComputedShortProperty is primitive-typed version of QComputedProperty<Short>.final class
QDoubleProperty is primitive-typed version of QProperty<Double>.final class
QFloatProperty is primitive-typed version of QProperty<Float>.final class
QIntProperty is primitive-typed version of QProperty<Integer>.final class
QLongProperty is primitive-typed version of QProperty<Long>.final class
TheQProperty
class enables automatic property bindings.final class
QShortProperty is primitive-typed version of QProperty<Short>.class
Watches the lifetime of multiple QObjectsclass
Java wrapper for Qt classQOperatingSystemVersionBase
class
Parallel group of animationsclass
Represents the result of a comparison that allows for unordered resultsclass
Pause for QSequentialAnimationGroupclass
Java wrapper for Qt's class QPermissionclass
Used to locate data in a data modelclass
Loads a plugin at run-timeclass
Defines a point in the plane using integer precisionclass
Defines a point in the plane using floating point precisionclass
Used to start external programs and to communicate with themclass
Holds the environment variables that can be passed to a programfinal class
QProperty<T>
Java wrapper for Qt class QPropertyfinal class
Deprecated, for removal: This API element is subject to removal in a future version.Class was only meant for internal use, use aQProperty
and add a binding to the targetclass
Animates Qt propertiesfinal class
Java wrapper for Qt class QPropertyBindingclass
Java wrapper for Qt classQPropertyBindingError
final class
Java wrapper for Qt class QPropertyChangeHandlerclass
The QPropertyData class is a helper class for properties with automatic property bindings.final class
Java wrapper for Qt class QPropertyNotifierclass
Java wrapper for Qt classQPropertyObserver
class
Java wrapper for Qt classQPropertyObserverBase
class
QQueue<T>
Java wrapper for Qt classQQueue
class
Allows one to obtain random values from a high-quality Random Number Generatorclass
Convenience class that simplifies locking and unlocking read-write locks for read accessclass
Read-write lockingclass
Defines a rectangle in the plane using integer precisionclass
Defines a finite rectangle in the plane using floating point precisionclass
Access serialization between threadsclass
Pattern matching using regular expressionsclass
The results of a matching a QRegularExpression against a stringclass
Iterator on the results of a global match of a QRegularExpression object against a stringclass
Interface for reading directly from resourcesclass
Interface for safely writing to filesclass
General counting semaphoreclass
Exception-safe deferral of a QSemaphore::release() callclass
Sequential group of animationsclass
Java-iterable wrapper for Qt's constant iterator types:final class
Java-iterable wrapper for Qt's iterator types:class
QSet<T>
Java wrapper for Qt classQSet
class
Persistent platform-independent application settingsclass
Access to a shared memory segmentfinal class
QShortBindable is primitive-typed version of QBindable<Short>.final class
QShortProperty is primitive-typed version of QProperty<Short>.final class
Deprecated, for removal: This API element is subject to removal in a future version.Class was only meant for internal use, use aQProperty
and add a binding to the targetfinal class
QShortPropertyBinding is primitive-typed version of QPropertyBinding<Short>.class
QShortPropertyData is primitive-typed version of QPropertyData<Short>.class
Exception-safe wrapper around QObject::blockSignals()class
Bundles signals from identifiable sendersclass
Defines the size of a two-dimensional object using integer point precisionclass
Defines the size of a two-dimensional object using floating point precisionclass
Support for monitoring activity on a file descriptorclass
Support for sorting and filtering data passed between another model and a viewfinal class
QSpan<T>
Java wrapper for Qt classQSpan
class
QStack<T>
Java wrapper for Qt classQStack
final class
Methods for accessing standard pathsclass
Struct containing a reference to a static plugin instance together with its meta dataclass
Provides information about currently mounted storage and drivesclass
Unicode character stringclass
Base class for encoding and decoding textclass
Java wrapper for Qt classQStringConverterBase
static class
Java wrapper for Qt classQStringConverterBase::State
class
State-based decoder for textclass
State-based encoder for textclass
List of stringsclass
Model that supplies strings to viewsclass
Holds a sequence of characters that can be quickly matched in a Unicode stringclass
General counting system semaphorestatic class
Qt::partial_ordering represents the result of a comparison that allows for unordered resultsstatic class
Qt::strong_ordering represents a comparison where equivalent values are indistinguishablestatic class
Qt::weak_ordering represents a comparison where equivalent values are still distinguishableclass
Creates a unique directory for temporary useclass
I/O device that operates on temporary filesclass
Way of finding Unicode text boundaries in a stringclass
Convenient interface for reading and writing textclass
Platform-independent way to manage threadsclass
Manages a collection of QThreadsclass
Per-thread data storageclass
Clock time functionsclass
Timeline for controlling animationsclass
Repetitive and single-shot timersclass
Contains parameters that describe a timer eventclass
Identifies how a time representation relates to UTCstatic class
Java wrapper for Qt classQTimeZone::OffsetData
class
Internationalization support for text outputclass
This proxy transposes the source modelclass
Uniform interface over bindable properties like QProperty\<T\> and QObjectBindableProperty of any type Tclass
Java wrapper for Qt classQUntypedPropertyBinding
class
Java wrapper for Qt classQUntypedPropertyData
class
Convenient interface for working with URLsclass
Way to manipulate a key-value pairs in a URL's queryclass
Stores a Universally Unique Identifier (UUID)static final class
Java wrapper for Qt classQUuid::Id128Bytes
class
Acts like a union for the most common Qt data typesclass
Base class for animationsclass
Contains a version number with an arbitrary number of segmentsclass
Condition variable for synchronizing threadsclass
Convenience class that simplifies locking and unlocking read-write locks for write accessclass
Represents a single XML attributeclass
Represents a vector of QXmlStreamAttributeclass
Represents a DTD entity declarationclass
Entity resolver for a QXmlStreamReaderclass
Represents a namespace declarationclass
Represents a DTD notation declarationclass
Fast parser for reading well-formed XML via a simple streaming APIclass
XML writer with a simple streaming APIModifier and TypeMethodDescription<T extends QtObjectInterface>
TQScope.capture
(T object) The given object is managed by the scope, i.e.static <T extends QtObjectInterface>
TQFunctionPointer.cast
(QtObjectInterface function, Class<T> functionalInterface) Converts the given function into given functional interface type.final <T extends QtObjectInterface>
TConverts this function pointer into given functional interface type.static <T extends QtObjectInterface>
TQMetaObject.cast
(Class<T> targetType, QtObjectInterface object) Casts an object to the given targetType.<O extends QtObjectInterface>
OQScope.create
(QScope.Factory<O> factory) Creates a new object being managed by this scope.<O extends QtObjectInterface,
A>
OQScope.create
(QScope.Factory1<A, O> factory, A arg0) Creates a new object being managed by this scope.<O extends QtObjectInterface,
A, B>
OQScope.create
(QScope.Factory2<A, B, O> factory, A arg0, B arg1) Creates a new object being managed by this scope.<O extends QtObjectInterface,
A, B, C>
OQScope.create
(QScope.Factory3<A, B, C, O> factory, A arg0, B arg1, C arg2) Creates a new object being managed by this scope.<O extends QtObjectInterface,
A, B, C, D>
OQScope.create
(QScope.Factory4<A, B, C, D, O> factory, A arg0, B arg1, C arg2, D arg3) Creates a new object being managed by this scope.<O extends QtObjectInterface,
A, B, C, D, E>
OQScope.create
(QScope.Factory5<A, B, C, D, E, O> factory, A arg0, B arg1, C arg2, D arg3, E arg4) Creates a new object being managed by this scope.<O extends QtObjectInterface,
A, B, C, D, E, F>
OQScope.create
(QScope.Factory6<A, B, C, D, E, F, O> factory, A arg0, B arg1, C arg2, D arg3, E arg4, F arg5) Creates a new object being managed by this scope.<O extends QtObjectInterface,
A, B, C, D, E, F, G>
OQScope.create
(QScope.Factory7<A, B, C, D, E, F, G, O> factory, A arg0, B arg1, C arg2, D arg3, E arg4, F arg5, G arg6) Creates a new object being managed by this scope.<O extends QtObjectInterface,
A, B, C, D, E, F, G, H>
OQScope.create
(QScope.Factory8<A, B, C, D, E, F, G, H, O> factory, A arg0, B arg1, C arg2, D arg3, E arg4, F arg5, G arg6, H arg7) Creates a new object being managed by this scope.<O extends QtObjectInterface,
A, B, C, D, E, F, G, H, I>
OQScope.create
(QScope.Factory9<A, B, C, D, E, F, G, H, I, O> factory, A arg0, B arg1, C arg2, D arg3, E arg4, F arg5, G arg6, H arg7, I arg8) Creates a new object being managed by this scope.static <O extends QtObjectInterface>
QScopedArrayPointer<O>QScopedArrayPointer.disposing
(O ... data) Creates a scoped pointer for the given objects performingdispose()
on each object at cleanup.static <O extends QtObjectInterface>
QScopedPointer<O>QScopedPointer.disposing
(O data) Creates a scoped pointer for the given object performingdispose()
at cleanup.final <QNativeInterface extends QtObjectInterface>
QNativeInterfaceQCoreApplication.nativeInterface
(Class<QNativeInterface> nativeInterfaceClass) static <O extends QtObjectInterface>
voidQScopedArrayPointer.performAndDispose
(Consumer<O[]> action, O... data) Performs an action on resources which will be disposes subsequently.static <O extends QtObjectInterface,
R>
RQScopedArrayPointer.performAndDispose
(Function<O[], R> action, O... data) Performs an action on resources which will be disposes subsequently.static <O extends QtObjectInterface>
doubleQScopedArrayPointer.performAndDispose
(ToDoubleFunction<O[]> action, O... data) Performs an action on resources which will be disposes subsequently.static <O extends QtObjectInterface>
intQScopedArrayPointer.performAndDispose
(ToIntFunction<O[]> action, O... data) Performs an action on resources which will be disposes subsequently.static <O extends QtObjectInterface>
longQScopedArrayPointer.performAndDispose
(ToLongFunction<O[]> action, O... data) Performs an action on resources which will be disposes subsequently.static <O extends QtObjectInterface>
voidQScopedPointer.performAndDispose
(Consumer<O> action, O data) Performs an action on a resource which will be disposes subsequently.static <O extends QtObjectInterface,
R>
RQScopedPointer.performAndDispose
(Function<O, R> action, O data) Performs an action on a resource which will be disposes subsequently.static <O extends QtObjectInterface>
doubleQScopedPointer.performAndDispose
(ToDoubleFunction<O> action, O data) Performs an action on a resource which will be disposes subsequently.static <O extends QtObjectInterface>
intQScopedPointer.performAndDispose
(ToIntFunction<O> action, O data) Performs an action on a resource which will be disposes subsequently.static <O extends QtObjectInterface>
longQScopedPointer.performAndDispose
(ToLongFunction<O> action, O data) Performs an action on a resource which will be disposes subsequently.static <T extends QtObjectInterface>
TQObject.qobject_cast
(Class<T> targetType, QObject object) final <T extends QtObjectInterface>
TQObject.qt_metacast
(Class<T> targetType) Casts an object to the given targetType.static <T extends QtObjectInterface>
TQVariant.qvariant_cast
(Object object, Class<T> targetType, QMetaType ... instantiations) Modifier and TypeMethodDescriptionstatic <T extends QtObjectInterface>
TQFunctionPointer.cast
(QtObjectInterface function, Class<T> functionalInterface) Converts the given function into given functional interface type.static <T extends QtObjectInterface>
TQMetaObject.cast
(Class<T> targetType, QtObjectInterface object) Casts an object to the given targetType.static <O extends QtObjectInterface>
QScopedArrayPointer<O>QScopedArrayPointer.disposing
(O ... data) Creates a scoped pointer for the given objects performingdispose()
on each object at cleanup.static <O extends QtObjectInterface>
voidQScopedArrayPointer.performAndDispose
(Consumer<O[]> action, O... data) Performs an action on resources which will be disposes subsequently.static <O extends QtObjectInterface,
R>
RQScopedArrayPointer.performAndDispose
(Function<O[], R> action, O... data) Performs an action on resources which will be disposes subsequently.static <O extends QtObjectInterface>
doubleQScopedArrayPointer.performAndDispose
(ToDoubleFunction<O[]> action, O... data) Performs an action on resources which will be disposes subsequently.static <O extends QtObjectInterface>
intQScopedArrayPointer.performAndDispose
(ToIntFunction<O[]> action, O... data) Performs an action on resources which will be disposes subsequently.static <O extends QtObjectInterface>
longQScopedArrayPointer.performAndDispose
(ToLongFunction<O[]> action, O... data) Performs an action on resources which will be disposes subsequently.Modifier and TypeMethodDescriptionstatic void
QPluginLoader.qRegisterPluginInterface
(Class<? extends QtObjectInterface> iface) static void
QPluginLoader.registerPluginInterface
(Class<? extends QtObjectInterface> factoryClass) Deprecated.UseQPluginLoader.qRegisterPluginInterface(Class)
instead. -
Uses of QtObjectInterface in io.qt.core.internal
Modifier and TypeClassDescriptionclass
Java wrapper for Qt classQAbstractFileEngine
class
Java wrapper for Qt classQAbstractFileEngineHandler
class
Java wrapper for Qt classQAbstractFileEngineIterator
class
Java wrapper for Qt classQFactoryLoader
class
Java wrapper for Qt classQFSFileEngine
class
Java wrapper for Qt classQPluginParsedMetaData
Modifier and TypeMethodDescriptionfinal <P extends QtObjectInterface,
R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method1<P, R> create, String key) final <P extends QtObjectInterface,
A, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method2<P, A, R> create, String key, A a) final <P extends QtObjectInterface,
R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method2<P, String, R> create, String key) final <P extends QtObjectInterface,
A, B, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method3<P, A, B, R> create, String key, A a, B b) final <P extends QtObjectInterface,
A, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method3<P, String, A, R> create, String key, A a) final <P extends QtObjectInterface,
A, B, C, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method4<P, A, B, C, R> create, String key, A a, B b, C c) final <P extends QtObjectInterface,
A, B, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method4<P, String, A, B, R> create, String key, A a, B b) final <P extends QtObjectInterface,
A, B, C, D, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method5<P, A, B, C, D, R> create, String key, A a, B b, C c, D d) final <P extends QtObjectInterface,
A, B, C, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method5<P, String, A, B, C, R> create, String key, A a, B b, C c) final <P extends QtObjectInterface,
A, B, C, D, E, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method6<P, A, B, C, D, E, R> create, String key, A a, B b, C c, D d, E e) final <P extends QtObjectInterface,
A, B, C, D, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method6<P, String, A, B, C, D, R> create, String key, A a, B b, C c, D d) final <P extends QtObjectInterface,
A, B, C, D, E, F, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method7<P, A, B, C, D, E, F, R> create, String key, A a, B b, C c, D d, E e, F f) final <P extends QtObjectInterface,
A, B, C, D, E, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method7<P, String, A, B, C, D, E, R> create, String key, A a, B b, C c, D d, E e) final <P extends QtObjectInterface,
A, B, C, D, E, F, G, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method8<P, A, B, C, D, E, F, G, R> create, String key, A a, B b, C c, D d, E e, F f, G g) final <P extends QtObjectInterface,
A, B, C, D, E, F, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method8<P, String, A, B, C, D, E, F, R> create, String key, A a, B b, C c, D d, E e, F f) final <P extends QtObjectInterface,
A, B, C, D, E, F, G, H, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method9<P, A, B, C, D, E, F, G, H, R> create, String key, A a, B b, C c, D d, E e, F f, G g, H h) final <P extends QtObjectInterface,
A, B, C, D, E, F, G, R>
RQFactoryLoader.loadPlugin
(QMetaObject.Method9<P, String, A, B, C, D, E, F, G, R> create, String key, A a, B b, C c, D d, E e, F f, G g) final <P extends QtObjectInterface>
PQFactoryLoader.loadPlugin
(Class<P> pluginClass, String key, Object... args) Modifier and TypeMethodDescriptionstatic void
QFactoryLoader.registerFactory
(Class<? extends QtObjectInterface> factoryClass) ModifierConstructorDescriptionQFactoryLoader
(Class<? extends QtObjectInterface> iid) Overloaded constructor forQFactoryLoader(java.lang.Class, java.lang.String, io.qt.core.Qt.CaseSensitivity)
QFactoryLoader
(Class<? extends QtObjectInterface> iid, String suffix) Overloaded constructor forQFactoryLoader(java.lang.Class, java.lang.String, io.qt.core.Qt.CaseSensitivity)
witharg__3 = io.qt.core.Qt.CaseSensitivity.CaseSensitive
.QFactoryLoader
(Class<? extends QtObjectInterface> iid, String suffix, Qt.CaseSensitivity arg__3) SeeQFactoryLoader::
QFactoryLoader(const char*, QString, Qt::CaseSensitivity) -
Uses of QtObjectInterface in io.qt.core.nativeinterface
Modifier and TypeInterfaceDescriptioninterface
Native interface to a core application on Android -
Uses of QtObjectInterface in io.qt.datavis
Modifier and TypeClassDescriptionclass
Methods for rendering 3D bar graphsclass
Representation of a camera in 3D spaceclass
Basic wheel mouse based input handlerclass
Representation of a light source in 3D spaceclass
Simple base class for all the objects in a 3D sceneclass
Methods for rendering 3D scatter graphsclass
Description of the 3D scene being visualizedclass
Methods for rendering 3D surface plotsclass
Visual style for graphsclass
Base class for the axes of a 3D graphclass
Window and render loop for graphsclass
Base class for implementations of input handlersclass
Base class for all 3D data seriesclass
Base class for all 3D graph proxiesclass
Represents a data series in a 3D bar graphclass
Template class that provides a dynamic arrayclass
Container for resolved data to be added to bar graphsclass
The data proxy for a 3D bars graphclass
Template class that provides a dynamic arrayclass
Manipulates an axis of a graphclass
Adds a custom item to a graphclass
Adds a custom label to a graphclass
Adds a volume rendered object to a graphclass
Base proxy class for Q3DSurfaceWidgetItemclass
Proxy class for presenting data in item models with Q3DBarsWidgetItemclass
Proxy class for presenting data in item models with Q3DScatterWidgetItemclass
Proxy class for presenting data in item models with Q3DSurfaceWidgetItemclass
Formatting rules for a logarithmic value axisclass
Represents a data series in a 3D scatter graphclass
Template class that provides a dynamic arrayclass
Container for resolved data to be added to scatter graphsclass
The data proxy for 3D scatter graphsclass
Represents a data series in a 3D surface graphclass
Template class that provides a dynamic arrayclass
Container for resolved data to be added to surface graphsclass
The data proxy for a 3D surface graphclass
Template class that provides a dynamic arrayclass
Basic touch display based input handlerclass
Manipulates an axis of a graphclass
Base class for 3D value axis formatters -
Uses of QtObjectInterface in io.qt.dbus
Modifier and TypeInterfaceDescriptioninterface
Allows slots to determine the D-Bus context of the callsinterface
Refers to one pending asynchronous callModifier and TypeClassDescriptionclass
The base class of D-Bus adaptor classesclass
The base class for all D-Bus interfaces in the Qt D-Bus binding, allowing access to remote interfacesclass
Java wrapper for Qt classQDBusAbstractInterfaceBase
class
Used to marshall and demarshall D-Bus argumentsclass
Represents a connection to the D-Bus bus daemonfinal class
Access to the D-Bus bus daemon serviceclass
Represents an error received from the D-Bus bus or from remote applications found in the busclass
Proxy for interfaces on remote objectsclass
Represents one message sent or received over the D-Bus busclass
Enables the programmer to identify the OBJECT_PATH type provided by the D-Bus typesystemclass
Convenient way for waiting for asynchronous repliesclass
The QDBusPendingReply class contains the reply to an asynchronous method call.class
QDBusPendingReply2<A,
B> The QDBusPendingReply class contains the reply to an asynchronous method call.class
QDBusPendingReply3<A,
B, C> The QDBusPendingReply class contains the reply to an asynchronous method call.class
QDBusPendingReply4<A,
B, C, D> The QDBusPendingReply class contains the reply to an asynchronous method call.class
QDBusPendingReply5<A,
B, C, D, E> The QDBusPendingReply class contains the reply to an asynchronous method call.class
QDBusPendingReply6<A,
B, C, D, E, F> The QDBusPendingReply class contains the reply to an asynchronous method call.class
QDBusPendingReply7<A,
B, C, D, E, F, G> The QDBusPendingReply class contains the reply to an asynchronous method call.class
QDBusPendingReply8<A,
B, C, D, E, F, G, H> The QDBusPendingReply class contains the reply to an asynchronous method call.final class
QDBusReply<T>
The QDBusReply class stores the reply for a method call to a remote object.class
Peer-to-peer communication between processes on the same computerclass
Allows the user to watch for a bus service changeclass
Enables the programmer to identify the SIGNATURE type provided by the D-Bus typesystemclass
Holds one Unix file descriptorclass
Enables the programmer to identify the variant type provided by the D-Bus typesystemclass
Used to handle several DBus paths with one class -
Uses of QtObjectInterface in io.qt.designer
Modifier and TypeInterfaceDescriptioninterface
Interface for extension factories in Qt Widgets Designerinterface
Interface for extension managers in Qt Widgets Designerinterface
Allows you to add pages to a custom multi-page container in Qt Widgets Designer's workspaceinterface
Allows you to include several custom widgets in one single libraryinterface
Enables Qt Widgets Designer to access and construct custom widgetsinterface
Java wrapper for Qt classQDesignerDnDItemInterface
interface
Allows you to manipulate a widget's dynamic properties in Qt Widgets Designer's property editorinterface
Java wrapper for Qt classQDesignerFormEditorPluginInterface
interface
Allows you to query and modify a form window's widget selection, and in addition modify the properties of all the form's widgetsinterface
Java wrapper for Qt classQDesignerLanguageExtension
interface
Java wrapper for Qt classQDesignerLayoutDecorationExtension
interface
Allows you to manipulate a widget's member functions which is displayed when configuring connections using Qt Widgets Designer's mode for editing signals and slotsinterface
Java wrapper for Qt classQDesignerMetaDataBaseItemInterface
interface
Java wrapper for Qt classQDesignerOptionsPageInterface
interface
Java wrapper for Qt classQDesignerPromotionInterface
interface
Allows you to manipulate a widget's properties which is displayed in Qt Designer's property editorinterface
Java wrapper for Qt classQDesignerSettingsInterface
interface
Allows you to add custom menu entries to Qt Widgets Designer's task menuinterface
Java wrapper for Qt classQDesignerWidgetDataBaseItemInterface
Modifier and TypeClassDescriptionclass
Default implementation for classes that create user interfaces at run-timeclass
Allows you to change the focus of Qt Widgets Designer's action editorclass
Allows you to access Qt Widgets Designer's various componentsclass
Allows you to query and manipulate form windows appearing in Qt Widgets Designer's workspaceclass
Java wrapper for Qt classQDesignerFormWindowToolInterface
class
Java wrapper for Qt classQDesignerIntegration
class
Java wrapper for Qt classQDesignerIntegrationInterface
class
Java wrapper for Qt classQDesignerMetaDataBaseInterface
class
Java wrapper for Qt classQDesignerNewFormWidgetInterface
class
Allows you to change the focus of Qt Widgets Designer's object inspectorstatic class
Java wrapper for Qt classQDesignerPromotionInterface::PromotedClass
class
Allows you to query and manipulate the current state of Qt Widgets Designer's property editorclass
Java wrapper for Qt classQDesignerResourceBrowserInterface
class
Allows you to control the contents of Qt Widgets Designer's widget boxstatic class
Java wrapper for Qt classQDesignerWidgetBoxInterface::Category
static class
Java wrapper for Qt classQDesignerWidgetBoxInterface::Widget
class
Java wrapper for Qt classQDesignerWidgetDataBaseInterface
class
Java wrapper for Qt classQDesignerWidgetFactoryInterface
class
Extension management facilities for Qt Widgets Designerclass
Used to dynamically construct user interfaces from UI files at run-time -
Uses of QtObjectInterface in io.qt.designer.util
Modifier and TypeClassDescriptionfinal class
Generic implementation forQDesignerCustomWidgetInterface
. -
Uses of QtObjectInterface in io.qt.graphs
Modifier and TypeClassDescriptionclass
Description of the 3D scene being visualizedclass
Base class for the axes of a 3D graphclass
Base class for all 3D data seriesclass
Base class used for specialized axis classesclass
Base class for all 3D graph proxiesclass
Base class for all Qt Graphs for 2D seriesclass
Presents data in area graphsclass
Represents a data series in a 3D bar graphclass
Adds categories to a graph's axesclass
Template class that provides a dynamic arrayclass
Container for resolved data to be added to bar graphsclass
The data proxy for a 3D bars graphclass
Template class that provides a dynamic arrayclass
Model mapper for bar seriesclass
Presents data in bar graphsclass
Represents one set of bars in a bar graphclass
Manipulates an axis of a graphclass
Adds a custom item to a graphclass
Adds a custom label to a graphclass
Adds a volume rendered object to a graphclass
Adds support for DateTime values to be added to a graph's axisclass
Java wrapper for Qt classQGraphsLine
class
Visual style for graphsclass
Java wrapper for Qt classQGraphsThemeDirtyBitField
class
Base proxy class for Q3DSurfaceWidgetItemclass
Proxy class for presenting data in item models with Q3DBarsWidgetItemclass
Proxy class for presenting data in item models with Q3DScatterWidgetItemclass
Proxy class for presenting data in item models with Q3DSurfaceWidgetItemclass
Struct contains information to display on a sets legend markerclass
Presents data in line graphsclass
Formatting rules for a logarithmic value axisclass
Model mapper for pie seriesclass
Presents data in pie graphsclass
Represents a single slice in a pie seriesclass
Represents a data series in a 3D scatter graphclass
Template class that provides a dynamic arrayclass
Container for resolved data to be added to scatter graphsclass
The data proxy for 3D scatter graphsclass
Presents data in scatter graphsclass
Presents data in spline graphsclass
Represents a data series in a 3D surface graphclass
Template class that provides a dynamic arrayclass
Container for resolved data to be added to surface graphsclass
The data proxy for a 3D surface graphclass
Template class that provides a dynamic arrayclass
Manipulates an axis of a graphclass
Base class for 3D value axis formattersclass
Adds values to a graph's axesclass
Model mapper for line, spline, and scatter seriesclass
Parent class for all x & y series classes -
Uses of QtObjectInterface in io.qt.graphs.widgets
Modifier and TypeClassDescriptionclass
Methods for rendering 3D bar graphsclass
Window and render loop for graphsclass
Methods for rendering 3D scatter graphsclass
Methods for rendering 3D surface plots -
Uses of QtObjectInterface in io.qt.gui
Modifier and TypeInterfaceDescriptioninterface
Java wrapper for Qt classQAbstractUndoItem
static interface
Java wrapper for Qt classQAccessible::ActivationObserver
static interface
Java wrapper for Qt callableQAccessible::InterfaceFactory
static interface
Java wrapper for Qt callableQAccessible::RootObjectHandler
static interface
Java wrapper for Qt callableQAccessible::UpdateHandler
interface
Implements support for invocable actions in the interfaceinterface
Implements support for reporting attributes for an accessible objectinterface
Implements support for objects with editable textinterface
Java wrapper for Qt classQAccessibleHyperlinkInterface
interface
Java wrapper for Qt classQAccessibleImageInterface
interface
Defines an interface that exposes information about accessible objectsinterface
Implements support for selection handlinginterface
Implements support for the IAccessibleTable2 Cell interfaceinterface
Implements support for the IAccessibleTable2 interfaceinterface
Implements support for text handlinginterface
Implements support for objects that manipulate a valueinterface
Represents a paint device that supports multiple pagesinterface
The base class of objects that can be painted on with QPainterinterface
Abstraction of renderable surfaces in Qtstatic interface
Java wrapper for Qt callableQTextDocument::ResourceProvider
interface
Allows drawing of custom text objects in QTextDocumentsModifier and TypeClassDescriptionclass
File icons for the QFileSystemModel classclass
Abstract base class used to implement custom layouts for QTextDocumentsstatic class
QAbstractTextDocumentLayout::PaintContext class is a convenience class defining the parameters used when painting a document's layoutstatic class
QAbstractTextDocumentLayout::Selection class is a convenience class defining the parameters of a selectionfinal class
Enums and static functions related to accessibilitystatic class
Java wrapper for Qt classQAccessible::State
class
Used to request the announcement of a given message by assistive technologiesclass
Java wrapper for Qt classQAccessibleApplication
class
Java wrapper for Qt classQAccessibleBridge
class
Java wrapper for Qt classQAccessibleBridgePlugin
class
The base class for accessibility notificationsclass
Implements parts of the QAccessibleInterface for QObjectsclass
Abstract base class for plugins provinding accessibility information for user interface elementsclass
Notfies the accessibility framework that the state of an object has changedclass
Signifies a change in a table, list, or tree where cells are added or removed.class
Notifies of cursor movementsclass
Notifies of text being insertedclass
Notifies of text being deletedclass
Signals a change in the text selection of an objectclass
Notifies about text changes.class
Describes a change in value for an accessible objectclass
Abstraction for user commands that can be added to different user interface componentsclass
Event that is generated when a QAction is added, removed, or changedclass
Groups actions togetherclass
Java wrapper for Qt classQApplicationStateChangeEvent
class
Drawing area for QWindowclass
Monochrome (1-bit depth) pixmapsclass
Defines the fill pattern of shapes drawn by QPainterclass
Contains event parameters for child window changesfinal class
Access to the window system clipboardclass
Contains parameters that describe a close eventclass
Colors based on RGB, HSV or CMYK valuesclass
Color space abstractionclass
Transformation between color spacesclass
Used in combination with QBrush to specify a conical gradient brushclass
Contains parameters that describe a context menu eventclass
Mouse cursor with an arbitrary shapeclass
Methods for accessing common desktop servicesclass
Range checking of floating-point numbersclass
Support for MIME-based drag and drop data transferclass
Event which is sent to a widget when a drag and drop action enters itclass
Event that is sent to a widget when a drag and drop action leaves itclass
Event which is sent while a drag and drop action is in progressclass
Event which is sent when a drag and drop action is completedclass
Contains parameters that describe an enter eventclass
Information about a point in a QPointerEventclass
Contains event parameters for expose eventsclass
Event that will be sent when there is a request to open a file or a URLclass
Data model for the local filesystemclass
Contains event parameters for widget focus eventsclass
Specifies a query for a font used for drawing textstatic class
QFont::Tag type provides access to advanced font featuresclass
Information about the fonts available in the underlying window systemclass
General information about fontsclass
Font metrics informationclass
Font metrics informationclass
Abstract base class for pluginsclass
Creates plugin driversclass
Direct access to the internal glyphs in a fontclass
Used in combination with QBrush to specify gradient fillsclass
Manages the GUI application's control flow and main settingsclass
Event that is used to request helpful information about a particular point in a widgetclass
Event which is sent after a widget is hiddenclass
Contains parameters that describe a mouse eventclass
Scalable icons in different modes and statesclass
Indicates that a main icon drag has begunclass
Abstract base class for QIcon renderersstatic class
Java wrapper for Qt classQIconEngine::ScaledPixmapArgument
class
Abstract base for custom QIconEngine pluginsclass
Hardware-independent image representation that allows direct access to the pixel data, and can be used as a paint deviceclass
Defines the common image I/O interface for all image formats in Qtclass
Defines an interface for writing an image format pluginclass
Format independent interface for reading images from files or other devicesclass
Format independent interface for writing images to files or other devicesclass
Describes a device from which a QInputEvent originatesclass
The base class for events that describe user inputfinal class
Access to the active text input methodclass
Parameters for input method eventsstatic class
QInputMethodEvent::Attribute class stores an input method attributeclass
Event sent by the input context to input objectsclass
Validator that ensures a string contains a valid integer within a specified rangeclass
Stores a combination of a key with optional modifiersclass
Describes a key eventclass
Encapsulates a key sequence as used by shortcutsclass
Used in combination with QBrush to specify a linear gradient brushclass
Java wrapper for Qt classQMatrix2x2
class
Java wrapper for Qt classQMatrix2x3
class
Java wrapper for Qt classQMatrix2x4
class
Java wrapper for Qt classQMatrix3x2
class
Java wrapper for Qt classQMatrix3x3
class
Java wrapper for Qt classQMatrix3x4
class
Java wrapper for Qt classQMatrix4x2
class
Java wrapper for Qt classQMatrix4x3
class
Represents a 4x4 transformation matrix in 3D spaceclass
Contains parameters that describe a mouse eventclass
Contains event parameters for move eventsclass
Convenience class for playing movies with QImageReaderclass
Contains parameters that describe a gesture eventclass
Represents an offscreen surface in the underlying platformclass
Represents a native OpenGL context, enabling OpenGL rendering on a QSurfacefinal class
Represents a group of contexts sharing OpenGL resourcesclass
Cross-platform access to the OpenGL ES 3.0, 3.1 and 3.2 APIclass
Cross-platform access to the OpenGL ES 2.0 APIclass
Describes the size, orientation and margins of a pageclass
Represents a collection of page rangesstatic class
QPageRanges::Range struct holds the from and to endpoints of a rangeclass
Describes the size and name of a defined page sizeclass
Convenience subclass of QWindow that is also a QPaintDeviceclass
Abstract definition of how QPainter draws to a given device on a given platformclass
Information about the active paint engine's current stateclass
Performs low-level painting on widgets and other paint devicesstatic class
This class is used in conjunction with the QPainter::drawPixmapFragments() function to specify how a pixmap, or sub-rect of a pixmap, is drawnclass
Container for painting operations, enabling graphical shapes to be constructed and reusedstatic class
QPainterPath::Element class specifies the position and type of a subpathclass
Used to generate fillable outlines for a given painter pathclass
Contains event parameters for paint eventsclass
Contains color groups for each widget stateclass
Java wrapper for Qt classQPdfOutputIntent
class
Class to generate PDFs that can be used as a paint deviceclass
Defines how a QPainter should draw lines and outlines of shapesclass
Paint device that records and replays QPainter commandsclass
Class for describing different pixel layouts in graphics buffersclass
Off-screen image representation that can be used as a paint deviceclass
Application-wide cache for pixmapsstatic class
QPixmapCache::Key class can be used for efficient access to the QPixmapCacheclass
Used to notify about native platform surface eventsclass
A base class for pointer eventsclass
Describes a device from which mouse, touch or tablet events originateclass
Identifies a unique object, such as a tagged token or stylus, which is used with a pointing deviceclass
List of points using integer precisionclass
List of points using floating point precisionclass
Represents a quaternion consisting of a vector and scalarclass
Used in combination with QBrush to specify a radial gradient brushclass
Convenience class for using QPainter on a QWindowclass
Access to a single physical instance of a fontclass
Specifies a clip region for a painterclass
Used to check a string against a regular expressionclass
Contains event parameters for resize eventsclass
Struct contains a 64-bit RGB colorfinal class
Used to query screen propertiesclass
Java wrapper for Qt classQScreenOrientationChangeEvent
class
Sent when scrollingclass
Sent in preparation of scrollingfinal class
Access to the session managerclass
Used to create keyboard shortcutsclass
Event which is generated when the user presses a key combinationclass
Event that is sent when a widget is shownclass
A base class for pointer events containing a single point, such as mouse eventsclass
Item for use with the QStandardItemModel classclass
Generic model for storing custom dataclass
Enables optimized drawing of text when the text and its layout is updated rarelyclass
Event that is used to show messages in a status barfinal class
Contains platform specific hints and settingsclass
Represents the format of a QSurfaceclass
Allows you to define syntax highlighting rules, and in addition you can use the class to query a document's current formatting or user dataclass
Contains parameters that describe a Tablet eventclass
Container for text fragments in a QTextDocumentstatic class
QTextBlock::iterator class provides an iterator for reading the contents of a QTextBlockclass
Formatting information for blocks of text in a QTextDocumentclass
Container for text blocks within a QTextDocumentclass
Used to associate custom data with blocks of textclass
Formatting information for characters in a QTextDocumentclass
Offers an API to access and modify QTextDocumentsclass
Holds formatted textclass
Represents a piece of formatted text from a QTextDocumentclass
Format-independent interface for writing a QTextDocument to files or other devicesclass
Formatting information for a QTextDocumentclass
Holds a piece of text in a QTextDocument with a single QTextCharFormatclass
Represents a frame in a QTextDocumentstatic class
Iterator for reading the contents of a QTextFrameclass
Formatting information for frames in a QTextDocumentclass
Formatting information for images in a QTextDocumentclass
Represents an inline object in a QAbstractTextDocumentLayout and its implementationsclass
All the information required to draw text in a custom paint engineclass
Used to lay out and render textstatic class
QTextLayout::FormatRange structure is used to apply extra formatting information for a specified area in the text layout's contentclass
Encapsulates the different types of length used in a QTextDocumentclass
Represents a line of text inside a QTextLayoutclass
Decorated list of items in a QTextDocumentclass
Formatting information for lists in a QTextDocumentclass
Base class for different kinds of objects that can group parts of a QTextDocument togetherclass
Description of general rich text propertiesstatic class
Java wrapper for Qt classQTextOption::Tab
class
Represents a table in a QTextDocumentclass
Represents the properties of a cell in a QTextTableclass
Formatting information for table cells in a QTextDocumentclass
Formatting information for tables in a QTextDocumentclass
Contains parameters that describe a touch eventclass
Specifies 2D transformations of a coordinate systemclass
The base class of all commands stored on a QUndoStackclass
Group of QUndoStack objectsclass
Stack of QUndoCommand objectsclass
Converts between a MIME type and a Uniform Type Identifier (UTI) formatclass
Validation of input textclass
Represents a vector or vertex in 2D spaceclass
Represents a vector or vertex in 3D spaceclass
Represents a vector or vertex in 4D spaceclass
Event that can be used to handle hyperlinks in a "What's This?" textclass
Contains parameters that describe a wheel eventclass
Represents a window in the underlying windowing systemclass
Maps open-standard MIME to Window Clipboard formatsclass
The window state before a window state changeModifier and TypeMethodDescriptionfinal <QNativeInterface extends QtObjectInterface>
QNativeInterfaceQOffscreenSurface.nativeInterface
(Class<QNativeInterface> name) SeeQOffscreenSurface::
resolveInterface(const char*, int)const final <QNativeInterface extends QtObjectInterface>
QNativeInterfaceQOpenGLContext.nativeInterface
(Class<QNativeInterface> name) SeeQOpenGLContext::
resolveInterface(const char*, int)const final <QNativeInterface extends QtObjectInterface>
QNativeInterfaceQScreen.nativeInterface
(Class<QNativeInterface> name) final <QNativeInterface extends QtObjectInterface>
QNativeInterfaceQWindow.nativeInterface
(Class<QNativeInterface> name) SeeQWindow::
resolveInterface(const char*, int)const -
Uses of QtObjectInterface in io.qt.gui.gl
Modifier and TypeInterfaceDescriptioninterface
Java wrapper for Qt callableGLDEBUGPROC
-
Uses of QtObjectInterface in io.qt.gui.nativeinterface
Modifier and TypeInterfaceDescriptioninterface
Native interface to a screeninterface
Native interface to an NSOpenGLContext on macOSinterface
Java wrapper for Qt classQNativeInterface::Private::QCocoaWindow
interface
Native interface to an EGL contextinterface
Native interface to a GLX contextinterface
Native interface to a screen on Waylandinterface
Native interface to a WGL context on Windowsinterface
Java wrapper for Qt classQNativeInterface::Private::QWindowsApplication
interface
Native interface to a screeninterface
Java wrapper for Qt classQNativeInterface::Private::QWindowsWindow
interface
Native interface to an X11 applicationinterface
Java wrapper for Qt classQNativeInterface::Private::QXcbScreen
interface
Java wrapper for Qt classQNativeInterface::Private::QXcbWindow
-
Uses of QtObjectInterface in io.qt.gui.qpa
Modifier and TypeClassDescriptionclass
Java wrapper for Qt classQPlatformIntegration
-
Uses of QtObjectInterface in io.qt.gui.rhi
Modifier and TypeInterfaceDescriptionstatic interface
Java wrapper for Qt callableQRhi::CleanupCallback
static interface
Java wrapper for Qt callablestd::function<void()>
Modifier and TypeClassDescriptionclass
Accelerated 2D/3D graphics API abstractionclass
Vertex, index, or uniform (constant) buffer resourcestatic class
Contains information about the underlying native resources of a bufferclass
Describes the a single color attachment of a render targetclass
Command buffer resourceclass
Compute pipeline state resourceclass
Direct3D 11 specific initialization parametersclass
Holds the D3D device and device context used by the QRhiclass
Holds the ID3D12GraphicsCommandList1 object that is backing a QRhiCommandBufferclass
Direct3D 12 specific initialization parametersclass
Holds the D3D12 device used by the QRhiclass
Specifies clear values for a depth or stencil bufferclass
Describes the physical device, adapter, or graphics API implementation that is used by an initialized QRhiclass
OpenGL specific initialization parametersclass
Holds the OpenGL context used by the QRhiclass
Graphics pipeline state resourcestatic class
Describes the stencil operation statestatic class
Describes the blend state for one color attachmentclass
Base class for backend-specific initialization parametersclass
Holds the MTLCommandBuffer and MTLRenderCommandEncoder objects that are backing a QRhiCommandBufferclass
Metal specific initialization parametersclass
Holds the Metal device used by the QRhiclass
Base class for classes exposing backend-specific collections of native resource objectsclass
Null backend specific initialization parametersclass
Emptyclass
Describes a readback (reading back texture contents from possibly GPU-only memory) operationclass
Describes the results of a potentially asynchronous buffer or texture readback operationclass
Renderbuffer resourcestatic class
Wraps a native renderbuffer objectclass
Render pass resourceclass
Represents an onscreen (swapchain) or offscreen (texture) render targetclass
Base class for classes encapsulating native resource objectsfinal class
Records upload and copy type of operationsclass
Sampler resourceclass
Specifies a scissor rectangleclass
Describes the shader resource for a single binding pointstatic class
Java wrapper for Qt classQRhiShaderResourceBinding::TextureAndSampler
class
Encapsulates resources for making buffer, texture, sampler resources visible to shadersclass
Specifies the type and the shader code for a shader stage in the pipelineclass
Statistics provided from the underlying memory allocatorclass
Swapchain resourceclass
Describes the high dynamic range related information of the swapchain's associated outputclass
Opaque data describing native objects needed to set up a swapchainclass
Swapchain render target resourceclass
Texture resourcestatic class
Contains information about the underlying native resources of a texturestatic class
Specifies the view format for reading or writing from or to the textureclass
Describes a texture-to-texture copy operationclass
Texture render target resourceclass
Describes the color and depth or depth/stencil attachments of a render targetclass
Describes the source for one mip level in a layer in a texture upload operationclass
Describes a texture upload operationclass
Describes one layer (face for cubemaps, slice for 3D textures, element for texture arrays) in a texture upload operationclass
Describes a single vertex input elementclass
Describes a vertex input bindingclass
Describes the layout of vertex inputs consumed by a vertex shaderclass
Specifies a viewport rectangleclass
Contains multiple versions of a shader translated to multiple shading languages, together with reflection metadatastatic class
Additional metadata about the native shader codestatic class
Mapping metadata for sampler uniformsclass
Contains source or binary code for a shader and additional metadataclass
Describes the interface of a shaderstatic class
Describes a member of a uniform or push constant blockstatic class
Describes a built-in variablestatic class
Describes an input or output variable in the shaderstatic class
Describes a push constant blockstatic class
Describes a shader storage blockstatic class
Describes a uniform blockclass
Specifies the shading language, the version with flags, and the variantclass
Specifies the shading language version -
Uses of QtObjectInterface in io.qt.help
Modifier and TypeClassDescriptionfinal class
Access to the details about a compressed help filefinal class
Item for use with QHelpContentModelfinal class
Model that supplies content to viewsfinal class
Tree view for displaying help content model itemsclass
Access to contents and indices of the help engineclass
The core functionality of the help systemfinal class
Details for the filters used by QHelpFilterEngineclass
Filtered view of the help contentsclass
Widget that allows for creating, editing and removing filtersfinal class
Model that supplies index keywords to viewsfinal class
List view displaying the QHelpIndexModelfinal class
Struct provides the data associated with a help linkclass
Access to widgets reusable to integrate fulltext search as well as to index and search documentationclass
Access to index and search documentationclass
Java wrapper for Qt classQHelpSearchQuery
class
Simple line edit or an advanced widget to enable the user to input a search term in a standardized input maskclass
The data associated with the search resultfinal class
Text browser to display search results -
Uses of QtObjectInterface in io.qt.httpserver
Modifier and TypeClassDescriptionclass
API to subclass to implement an HTTP serverfinal class
Simplified API for QAbstractHttpServer and QHttpServerRouterfinal class
Encapsulates an HTTP requestfinal class
API for sending replies from an HTTP serverfinal class
Encapsulates an HTTP responseclass
Provides functions to bind a URL to a ViewHandlerclass
The base class for QHttpServerRouter rulesfinal class
Response to return when verifying WebSocket upgrades on HTTP server -
Uses of QtObjectInterface in io.qt.insighttracker
Modifier and TypeClassDescriptionclass
Configuration class for the Qt Insight Trackerclass
Control the Qt Insight Tracker and send events to the back-end server -
Uses of QtObjectInterface in io.qt.internal
Modifier and TypeMethodDescriptionprotected static void
NativeUtility.disposeObject
(QtObjectInterface object) protected static QMetaObject.DisposedSignal
NativeUtility.getSignalOnDispose
(QtObjectInterface object, boolean forceCreation) Emitted either as the native resources that belong to the object are being cleaned up or directly before the object is finalized.protected static void
NativeUtility.initializeNativeObject
(Class<?> declaringClass, QtObjectInterface object, Map<Class<?>, List<?>> arguments) protected static boolean
NativeUtility.isObjectDisposed
(QtObjectInterface object) static boolean
TestUtility.isSharedPointer
(QtObjectInterface object) protected static void
CoreUtility.registerConDestroyedObject
(QtObjectInterface dependentObject, QtObject owner) protected static void
CoreUtility.registerConDestroyedObject
(QtObjectInterface dependentObject, QtObjectInterface owner) protected static void
CoreUtility.registerConDestroyedObject
(QtObject dependentObject, QtObjectInterface owner) static boolean
TestUtility.tryIsObjectDisposed
(QtObjectInterface object) Testing method...protected static void
CoreUtility.unregisterConDestroyedObject
(QtObjectInterface dependentObject, QtObject owner) protected static void
CoreUtility.unregisterConDestroyedObject
(QtObjectInterface dependentObject, QtObjectInterface owner) protected static void
CoreUtility.unregisterConDestroyedObject
(QtObject dependentObject, QtObjectInterface owner) -
Uses of QtObjectInterface in io.qt.keyboard
Modifier and TypeClassDescriptionclass
Base class for input methodsfinal class
An application-defined dictionary for virtual keyboard input methodsfinal class
Dictionary management for application-defined dictionariesclass
Provides access to an input contextfinal class
InputEngine class provides an input engine that supports C++ and QML integrationclass
Acts as a hub for keyboard event notificationsfinal class
List model for selection listsclass
Trace is a data model for touch input data -
Uses of QtObjectInterface in io.qt.location
Modifier and TypeInterfaceDescriptioninterface
Java wrapper for Qt classQGeoServiceProviderFactory
Modifier and TypeClassDescriptionclass
Manages an operation started by an instance of QGeoCodingManagerfinal class
Support for geocoding operationsclass
Interface and convenience methods to implementers of QGeoServiceProvider plugins who want to provide support for geocoding operationsclass
Represents the information relevant to the point at which two QGeoRouteSegments meetclass
Represents a route between two pointsclass
Manages an operation started by an instance of QGeoRoutingManagerclass
Represents the parameters and restrictions which define a request for routing informationclass
Represents a segment of a routefinal class
Support for geographic routing operationsclass
Interface and convenience methods to implementers of QGeoServiceProvider plugins who want to provide access to geographic routing informationclass
Aggregates access to services which provide geographical informationclass
Represents a set of data about a placeclass
Represents generic attribute information about a placeclass
Represents a category that a QPlace can be associated withclass
Represents a contact detail such as a phone number or website urlclass
Holds content about placesclass
Manages a content retrieval operation started by an instance of QPlaceManagerclass
Represents the parameters of a content requestclass
Manages a place details fetch operation started by an instance of QPlaceManagerclass
Represents an iconclass
Manages operations which return an identifier such as saving and removal operations of places and categoriesfinal class
The interface which allows clients to access places stored in a particular backendclass
Interface for implementers of QGeoServiceProvider plugins who want to provide access to place functionalityclass
Manages a place matching operation started by an instance of QPlaceManagerclass
Used to find places from one manager that match those from another.class
Represents a search result containing a proposed searchclass
Holds rating information about a placeclass
Manages an operation started by an instance of QPlaceManager and serves as a base class for more specialized repliesclass
Represents a search result containing a placeclass
Manages a place search operation started by an instance of QPlaceManagerclass
Represents the set of parameters for a search requestclass
The base class for search resultsclass
Manages a search suggestion operation started by an instance of QPlaceManagerclass
Represents a supplier of a place or content associated with a placeclass
Represents an individual user -
Uses of QtObjectInterface in io.qt.multimedia
Modifier and TypeClassDescriptionclass
Represents a collection of audio samples with a specific format and sample rateclass
Used for providing custom audio buffers to QMediaRecorder through QMediaCaptureSessionclass
Used for capturing audio data provided by QMediaPlayerclass
Java wrapper for Qt classQAudioDecoder
class
Information about audio devices and their functionalityclass
Stores audio stream parameter informationclass
Represents an input channel for audioclass
Represents an output channel for audioclass
Interface for sending audio data to an audio output deviceclass
Interface for receiving audio data from an audio input deviceclass
Interface for system camera devicesclass
General information about camera devicesclass
Describes a video format supported by a camera deviceclass
Used for getting the basic information of a capturable windowclass
Used for the recording of media contentclass
Allows capturing of audio and video contentclass
Information about available multimedia input and output devicesclass
Describes an encoding format for a multimedia file or streamclass
Provides meta-data for media filesclass
Allows the playing of a media filesclass
Used for encoding and recording a capture sessionclass
Represents a set of zero or more disjoint time intervalsstatic class
QMediaTimeRange::Interval class represents a time interval with integer precisionclass
This class is used for capturing a screenclass
Way to play low latency sound effectsclass
Represents a frame of video datastatic class
Java wrapper for Qt classQVideoFrame::PaintOptions
class
Specifies the stream format of a video presentation surfaceclass
Used for providing custom video frames to QMediaRecorder or a video output through QMediaCaptureSessionclass
Represents a generic sink for video dataclass
Java wrapper for Qt classQWaveDecoder
class
This class is used for capturing a window -
Uses of QtObjectInterface in io.qt.multimedia.widgets
Modifier and TypeClassDescriptionclass
Graphics item which display video produced by a QMediaPlayer or QCameraclass
Widget which presents video produced by a media object -
Uses of QtObjectInterface in io.qt.network
Modifier and TypeClassDescriptionclass
The interface for cache implementationsclass
The base functionality common to all socket typesclass
Authentication objectclass
Stores information about a domain name recordclass
Stores information about a host address recordclass
Represents a DNS lookupclass
Stores information about a DNS MX recordclass
Stores information about a DNS SRV recordclass
Stores information about a DNS TXT recordclass
Stores information about a DNS TLSA recordclass
This class provides encryption for UDP socketsclass
This class implements server-side DTLS cookie generation and verificationstatic class
This class defines parameters for DTLS cookie generatorclass
Convenience class to simplify the construction of QHttpMultiPart objectsclass
Convenience class to simplify the construction of QHttpPart objectsclass
IP addressclass
Static functions for host name lookupsclass
Specifies that a host supports HTTP Strict Transport Security policy (HSTS)class
Controls HTTP/1 parameters and settingsclass
Controls HTTP/2 parameters and settingsclass
Class for holding HTTP headersclass
Resembles a MIME multipart message to be sent over HTTPclass
Holds a body part to be used inside a HTTP multipart MIME messageclass
Java wrapper for Qt classQIPv6Address
class
Local socket based serverclass
Local socketclass
Allows the application to send network requests and receive repliesclass
Stores one IP address supported by a network interface, along with its associated netmask and broadcast addressclass
Cache informationclass
Holds one network cookieclass
Implements a simple jar of QNetworkCookie objectsclass
The data and metadata of a UDP datagramclass
Very basic disk cachefinal class
Exposes various network information through native backendsclass
Listing of the host's IP addresses and network interfacesclass
Network layer proxyclass
Fine-grained proxy selectionclass
Used to query the proxy settings for a socketclass
Contains the data and headers for a request sent with QNetworkAccessManagerclass
Holds a request to be sent with QNetworkAccessManagerclass
Convenience class for grouping remote server endpoints that share common network request propertiesclass
This class represents Online Certificate Status Protocol responseclass
Convenience wrapper for QNetworkAccessManagerclass
Convenience wrapper for QNetworkReplyclass
Convenient API for an X509 certificateclass
API for accessing the extensions of an X509 certificateclass
Represents an SSL cryptographic cipherclass
Holds the configuration and state of an SSL connectionclass
Interface for Diffie-Hellman parameters for serversclass
Represents an elliptic curve for use by elliptic-curve cipher algorithmsclass
SSL errorclass
Interface for private and public keysclass
Authentication data for pre shared keys (PSK) ciphersuitesclass
Implements an encrypted, secure TCP server over TLSclass
SSL encrypted socket for both clients and serversclass
TCP-based serverclass
TCP socketclass
UDP socket -
Uses of QtObjectInterface in io.qt.network.auth
Modifier and TypeInterfaceDescriptionstatic interface
Java wrapper for Qt callableQAbstractOAuth::ModifyParametersFunction
Modifier and TypeClassDescriptionclass
The base of all implementations of OAuth authentication methodsclass
The base of all implementations of OAuth 2 authentication methodsclass
Handles replies to OAuth authentication requestsclass
Implementation of the OAuth 1 Protocolclass
Implements OAuth 1 signature methodsclass
Implementation of the Authorization Code Grant flowclass
Handles loopback redirects by setting up a local HTTP serverclass
Java wrapper for Qt classQOAuthOobReplyHandler
class
Handles private/custom and https URI scheme redirects -
Uses of QtObjectInterface in io.qt.nfc
Modifier and TypeClassDescriptionclass
Filter for matching NDEF messagesstatic class
QNdefFilter::Record struct contains the information about a filter recordclass
NFC NDEF messageclass
NFC MIME record to hold an iconclass
NFC RTD-SmartPosterclass
NFC RTD-Textclass
NFC RTD-URIclass
NFC NDEF recordclass
Access to notifications for NFC eventsclass
Interface for communicating with a target devicestatic class
A request id handle -
Uses of QtObjectInterface in io.qt.opengl
Modifier and TypeClassDescriptionclass
The base class of a family of classes that expose all functions for each OpenGL version and profileclass
Functions for creating and managing OpenGL buffer objectsclass
Enables logging of OpenGL debugging messagesclass
Wraps an OpenGL debug messageclass
Encapsulates an OpenGL framebuffer objectclass
Specifies the format of an OpenGL framebuffer objectclass
All functions for OpenGL 1.0 specificationclass
All functions for OpenGL 1.1 specificationclass
All functions for OpenGL 1.2 specificationclass
All functions for OpenGL 1.3 specificationclass
All functions for OpenGL 1.4 specificationclass
All functions for OpenGL 1.5 specificationclass
All functions for OpenGL 2.0 specificationclass
All functions for OpenGL 2.1 specificationclass
All functions for OpenGL 3.0 specificationclass
All functions for OpenGL 3.1 specificationclass
All functions for OpenGL 3.2 compatibility profileclass
All functions for OpenGL 3.2 core profileclass
All functions for OpenGL 3.3 compatibility profileclass
All functions for OpenGL 3.3 core profileclass
All functions for OpenGL 4.0 compatibility profileclass
All functions for OpenGL 4.0 core profileclass
All functions for OpenGL 4.1 compatibility profileclass
All functions for OpenGL 4.1 core profileclass
All functions for OpenGL 4.2 compatibility profileclass
All functions for OpenGL 4.2 core profileclass
All functions for OpenGL 4.3 compatibility profileclass
All functions for OpenGL 4.3 core profileclass
All functions for OpenGL 4.4 compatibility profileclass
All functions for OpenGL 4.4 core profileclass
All functions for OpenGL 4.5 compatibility profileclass
All functions for OpenGL 4.5 core profileclass
All functions for OpenGL ES 2class
Enables painting to an OpenGL context using QPainterclass
Describes the pixel storage modes that affect the unpacking of pixels during texture uploadclass
Allows OpenGL shaders to be compiledclass
Allows OpenGL shader programs to be linked and usedclass
Encapsulates an OpenGL texture objectclass
Convenient way to draw textured quads via OpenGLclass
Provides access to OpenGL functions for a specified version and profileclass
Represents the version and if applicable the profile of an OpenGL contextclass
Java wrapper for Qt classQOpenGLVersionStatus
class
Wraps an OpenGL Vertex Array Objectstatic class
QOpenGLVertexArrayObject::Binder class is a convenience class to help with the binding and releasing of OpenGL Vertex Array Objectsclass
Convenience subclass of QWindow to perform OpenGL painting -
Uses of QtObjectInterface in io.qt.opengl.widgets
-
Uses of QtObjectInterface in io.qt.pdf
Modifier and TypeClassDescriptionclass
Holds a tree of of links (anchors) within a PDF document, such as the table of contentsclass
Loads a PDF document and renders pages from itclass
Holds the options to render a page from a PDF documentclass
Defines a link between a region on a page (such as a hyperlink or a search result) and a destination (page, location on the page, and zoom level at which to view it)class
Holds the geometry and the destination for each link that the specified page containsclass
Navigation history within a PDF documentclass
Encapsulates the rendering of pages of a PDF documentclass
Searches for a string in a PDF document and holds the resultsclass
Defines a range of text that has been selected on one page in a PDF document, and its geometric boundaries -
Uses of QtObjectInterface in io.qt.pdf.widgets
Modifier and TypeClassDescriptionclass
A widget for selecting a PDF pageclass
A PDF viewer widget -
Uses of QtObjectInterface in io.qt.positioning
Modifier and TypeInterfaceDescriptioninterface
Factory class used as the plugin interface for external providers of positioning dataModifier and TypeClassDescriptionclass
Represents an address of a QGeoLocationclass
Describes the parameters of an area or region to be monitored for proximityclass
Enables the detection of proximity changes for a specified set of coordinatesclass
Defines a circular geographic areaclass
Defines a geographical position on the surface of the Earthclass
Represents basic information about a locationclass
Defines a geographic pathclass
Defines a geographic polygonclass
Contains information gathered on a global position, direction and velocity at a particular point in timeclass
Abstract base class for the distribution of positional updatesclass
Defines a rectangular geographic areaclass
Contains basic information about a satelliteclass
Abstract base class for the distribution of satellite information updatesclass
Defines a geographic areaclass
Positional information using a NMEA data sourceclass
Satellite information using an NMEA data source -
Uses of QtObjectInterface in io.qt.printsupport
Modifier and TypeClassDescriptionclass
Base implementation for print dialogs used to configure printersclass
Configuration dialog for the page-related options on a printerclass
Dialog for specifying the printer's configurationclass
Defines an interface for how QPrinter interacts with a given printing subsystemclass
Paint device that paints on a printerclass
Gives access to information about existing printersclass
Dialog for previewing and configuring page layouts for printer outputclass
Widget for previewing page layouts for printer output -
Uses of QtObjectInterface in io.qt.qml
Modifier and TypeClassDescriptionfinal class
QQmlListProperty<T extends QtObjectInterface>
The QQmlListProperty class allows applications to expose list-like properties of QObject-derived classes to QML.Modifier and TypeInterfaceDescriptioninterface
Allows you to control QML file loadinginterface
Java wrapper for Qt classQQmlEngineExtensionInterface
interface
Java wrapper for Qt classQQmlExtensionInterface
interface
Instances drive the progress of QQmlIncubatorsinterface
Creates QNetworkAccessManager instances for a QML engineinterface
Updates on the QML parser stateinterface
Interface for property value sources such as animations and bindingsinterface
Java wrapper for Qt classQQmlTypesExtensionInterface
static interface
Java wrapper for Qt callableQtQml::ObjectCallback
static interface
Java wrapper for Qt callableQtQml::QQmlAttachedPropertiesFunc
static interface
Java wrapper for Qt callableQtQml::ValueCallback
Modifier and TypeClassDescriptionclass
Environment for evaluating JavaScript codeclass
Represents a value on the JavaScript heap belonging to a QJSEnginefinal class
Java wrapper for Qt classQJSNumberCoercion
class
Operates on primitive types in JavaScript semanticsclass
Acts as a container for Qt/JavaScript data typesclass
Java-style iterator for QJSValueclass
Convenient way to load an application from a single QML fileclass
Encapsulates a QML component definitionclass
Defines a context within a QML enginestatic class
Java wrapper for Qt classQQmlContext::PropertyPair
class
Java wrapper for Qt classQQmlDebuggingEnabler
class
Environment for instantiating QML componentsclass
Abstract base for custom QML extension pluginsclass
Encapsulates a QML errorclass
Evaluates JavaScript in a QML contextclass
Abstract base for custom QML extension plugins with custom type registration functionsclass
Static utility methods to categorize URLsclass
A class for applying a QFileSelector to QML file loadingclass
Used to register image providers in the QML engineclass
Allows QML objects to be created asynchronouslyclass
Allows logging of QML-related messagesfinal class
QQmlListProperty<T extends QtObjectInterface>
The QQmlListProperty class allows applications to expose list-like properties of QObject-derived classes to QML.class
Allows the manipulation of QQmlListProperty propertiesclass
Abstracts accessing properties on objects created from QMLclass
Allows you to set key-value pairs that can be used in QML bindingsclass
Encapsulates a script and its contextModifier and TypeMethodDescriptionfinal <T extends QtObjectInterface>
TQQmlEngine.singletonInstance
(Class<T> type, int qmlTypeId) final <T extends QtObjectInterface>
TQQmlEngine.singletonInstance
(Class<T> type, String moduleName, String typeName) Modifier and TypeMethodDescriptionstatic int
QtQml.qmlRegisterInterface
(Class<? extends QtObjectInterface> type, String uri, int versionMajor) SeeqmlRegisterInterface<T>(const char*,
int) -
Uses of QtObjectInterface in io.qt.qt3d.animation
Modifier and TypeClassDescriptionclass
An abstract base class for Qt3D animationsclass
The base class for types providing key frame animation dataclass
Java wrapper for Qt classQt3DAnimation::QAbstractChannelMapping
class
The base class for types providing animation playback capabilitiesclass
The base class for types used to construct animation blend treesclass
Performs an additive blend of two animation clips based on an additive factorclass
Provides key-frame animation capabilities to Qt 3Dclass
Represents an animation callback objectclass
Specifies key frame animation dataclass
Class containing the animation dataclass
Enables loading key frame animation data from a fileclass
A controller class for animationsclass
A class grouping animations togetherclass
Component providing animation playback capabilities of a tree of blend nodesclass
Allows to map the channels within the clip onto an invocation of a callback objectclass
Defines a channel for a QAnimationClipData.class
Java wrapper for Qt classQt3DAnimation::QChannelComponent
class
Allows to map the channels within the clip onto properties of objects in the applicationclass
Allows to map the channels within the clip onto properties of objects in the applicationclass
Component providing simple animation playback capabilitiesclass
Class used for including a clip in a blend treeclass
Java wrapper for Qt classQt3DAnimation::QClock
class
A base class for handling keyframesclass
A class implementing simple keyframe animation to a QTransformclass
Performs a linear interpolation of two animation clips based on a normalized factorclass
A class implementing blend-shape morphing animationclass
A class providing morph targets to blend-shape animationclass
Java wrapper for Qt classQt3DAnimation::QSkeletonMapping
class
A class implementing vertex-blend morphing animation -
Uses of QtObjectInterface in io.qt.qt3d.core
Modifier and TypeInterfaceDescriptioninterface
Abstract base class for all functorsModifier and TypeClassDescriptionclass
The base class for aspects that provide a vertical slice of behaviorclass
A skeleton contains the joints for a skinned meshclass
Used to calculate skinning transform matrices and set them on shadersclass
Responsible for handling all the QAbstractAspect subclasses that have been registered with the sceneclass
Base class for jobs executed in an aspectclass
Defines an attribute and how data should be read from a QBufferclass
Base class for all Qt3D backend nodesclass
Creates and maps backend nodes to their respective frontend nodesclass
Can be used to override the bounding volume of an entityclass
Provides a data store for raw data to later be used as vertices or uniformsclass
Base class of scene nodes that can be aggregated by Qt3DCore::QEntity instances as a componentclass
Java wrapper for Qt classQt3DCore::QCoreAspect
class
Holds settings related to core data handling processclass
Qt3DCore::QEntity is a Qt3DCore::QNode subclass that can aggregate several Qt3DCore::QComponent instances that will specify its behaviorclass
Encapsulates geometryclass
Encapsulates geometry detailsclass
Used to transforms parts of skinned meshesclass
The base class of all Qt3D node classes used to build a Qt3D sceneclass
Uniquely identifies a QNodeclass
Java wrapper for Qt classQt3DCore::QNodeIdTypePair
class
Holds the data for a skeleton to be used with skinned meshesclass
Used to load a skeleton of joints from fileclass
Used to perform transforms on meshes -
Uses of QtObjectInterface in io.qt.qt3d.core.quick
Modifier and TypeClassDescriptionclass
Environment for the QAspectEngine and a method for instantiating QML components -
Uses of QtObjectInterface in io.qt.qt3d.extras
Modifier and TypeClassDescriptionclass
Basic functionality for camera controllersstatic class
Java wrapper for Qt classQt3DExtras::QAbstractCameraController::InputState
class
Java wrapper for Qt classQt3DExtras::QAbstractSpriteSheet
class
Allows creation of a cone in 3D spaceclass
A conical meshclass
A conical meshclass
Allows creation of a cuboid in 3D spaceclass
A cuboid meshclass
A cuboid meshclass
Allows creation of a cylinder in 3D spaceclass
A cylindrical meshclass
A cylindrical meshclass
Java wrapper for Qt classQt3DExtras::QDiffuseMapMaterial
class
Java wrapper for Qt classQt3DExtras::QDiffuseSpecularMapMaterial
class
Default implementation of the phong lighting effectclass
Allows creation of a 3D extruded text in 3D spaceclass
A 3D extruded Text meshclass
Allows controlling the scene camera from the first person perspectiveclass
Default FrameGraph implementation of a forward rendererclass
Material that implements the Gooch shading model, popular in CAD and CAM applicationsclass
Default implementation of PBR lightingclass
Default implementation of the phong lighting effectclass
Java wrapper for Qt classQt3DExtras::QNormalDiffuseMapAlphaMaterial
class
Java wrapper for Qt classQt3DExtras::QNormalDiffuseMapMaterial
class
Java wrapper for Qt classQt3DExtras::QNormalDiffuseSpecularMapMaterial
class
Allows controlling the scene camera along orbital pathclass
Default implementation for rendering the color properties set for each vertexclass
Java wrapper for Qt classQt3DExtras::QPhongAlphaMaterial
class
Java wrapper for Qt classQt3DExtras::QPhongMaterial
class
Allows creation of a plane in 3D spaceclass
A square planar meshclass
A square planar meshclass
Qt3DExtras::QSkyboxEntity is a convenience Qt3DCore::QEntity subclass that can be used to insert a skybox in a 3D sceneclass
Allows creation of a sphere in 3D spaceclass
A spherical meshclass
A spherical meshclass
Java wrapper for Qt classQt3DExtras::QSpriteGrid
class
Java wrapper for Qt classQt3DExtras::QSpriteSheet
class
Java wrapper for Qt classQt3DExtras::QSpriteSheetItem
class
Java wrapper for Qt classQt3DExtras::Qt3DWindow
class
Allows creation of a 2D text in 3D spaceclass
Default implementation of a simple unlit texture materialclass
Allows creation of a torus in 3D spaceclass
A toroidal meshclass
A toroidal mesh -
Uses of QtObjectInterface in io.qt.qt3d.extras.quick
Modifier and TypeClassDescriptionclass
Java wrapper for Qt classQt3DExtras::Quick::Qt3DQuickWindow
-
Uses of QtObjectInterface in io.qt.qt3d.input
Modifier and TypeClassDescriptionclass
The base class for the Action Input and all Aggregate Action Inputsclass
QAbstractActionInput is the base class for all Axis Inputclass
The base class used by Qt3d to interact with arbitrary input devicesclass
Links a set of QAbstractActionInput that trigger the same eventclass
Stores Device and Buttons used to trigger an input eventclass
An axis input controlled by an analog input The axis value is controlled like a traditional analog input such as a joystickclass
Stores QAbstractAxisInputs used to trigger an input eventclass
Processes velocity or acceleration data from a QAxisclass
Stores settings for the specified list of Axisclass
An axis input controlled by buttons The axis value is controlled by buttons rather than a traditional analog input such as a joystickclass
Responsible for creating physical devices and handling associated jobsclass
Represents a set of QAbstractActionInput's that must be triggerd at onceclass
Represents a set of QAbstractActionInput's that must be triggerd one after the otherclass
Holds the pointer to an input event source objectclass
In charge of dispatching keyboard events to attached QQKeyboardHandler objectsclass
Provides keyboard event notificationclass
Event type send by KeyBoardHandlerclass
Allows the user to define a set of actions that they wish to use within an applicationclass
Delegates mouse events to the attached MouseHandler objectsclass
Qt3DCore::QMouseEvent contains parameters that describe a mouse eventclass
Provides a means of being notified about mouse events when attached to a QMouseDevice instanceclass
Contains parameters that describe a mouse wheel event -
Uses of QtObjectInterface in io.qt.qt3d.logic
Modifier and TypeClassDescriptionclass
Provides a way to have a synchronous function executed each frameclass
Responsible for handling frame synchronization jobs -
Uses of QtObjectInterface in io.qt.qt3d.render
Modifier and TypeInterfaceDescriptioninterface
Java wrapper for Qt classQt3DRender::PropertyReaderInterface
interface
Provides texture image data for QAbstractTextureImageModifier and TypeClassDescriptionclass
Encapsulate a QAbstractLight object in a Qt 3D sceneclass
An abstract base class for ray casting in 3d scenesclass
A base class to be used to provide texturesclass
Encapsulates the necessary information to create an OpenGL texture imageclass
Enable alpha-to-coverage multisampling modeclass
Specify alpha reference testclass
Specifies the equation used for both the RGB blend equation and the Alpha blend equationclass
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)class
FrameGraph node to transfer a rectangle of pixel values from one region of a render target to anotherclass
Exchanges buffer data between GPU and CPUclass
Defines a view point through which the scene will be renderedclass
Qt3DRender::QCameraLens specifies the projection matrix that will be used to define a Camera for a 3D sceneclass
Class to allow for selection of camera to be usedclass
Class to clear buffersclass
Enables an additional OpenGL clipping plane that can be in shaders using gl_ClipDistanceclass
Allows specifying which color components should be written to the currently bound frame bufferclass
QComponent to issue work for the compute shader on GPUclass
Specifies whether front or back face culling is enabledclass
Enables a visual overlay with scene detailsclass
Enables remapping depth values written into the depth bufferclass
Tests the fragment shader's depth value against the depth of a sample being written toclass
Encapsulate a Directional Light object in a Qt 3D sceneclass
FrameGraph node to issue work for the compute shader on GPUclass
Enable ditheringclass
Base class for effects in a Qt 3D sceneclass
Encapsulate an environment light object in a Qt 3D sceneclass
Storage for filter keys and their valuesclass
Base class of all FrameGraph configuration nodesclass
Defines front and back facing polygonsclass
Enable frustum culling for the FrameGraphclass
Encapsulates geometry renderingclass
Identifies the API required for the attached QTechniqueclass
Way of filtering which entities will be renderedclass
Controls layers drawn in a frame graph branchclass
Way of controlling the complexity of rendered entities based on their size on the screenclass
Simple spherical volume, defined by its center and radiusclass
Provides a way of enabling child entities based on distance or screen sizeclass
Specifies the width of rasterized linesclass
Provides an abstract class that should be the base of all material component classes in a sceneclass
Class to emplace a memory barrierclass
A custom mesh loaderclass
Enable multisample antialiasingclass
Disable depth writeclass
When a Qt3DRender::QNoDraw node is present in a FrameGraph branch, this prevents the renderer from rendering any primitiveclass
When a Qt3DRender::QNoPicking node is present in a FrameGraph branch, this prevents the render aspect from performing picking selection for the given branchclass
Instantiates a component that can be used to interact with a QEntity by a process known as pickingclass
A QAbstractTextureImage that can be written through a QPainterclass
Provides storage for a name and value pair.class
Holds information when an object is pickedclass
Can be used to provide an alternate QGeometryView used only for pickingclass
Specifies how entity picking is handledclass
Holds information when a segment of a line is pickedclass
Holds information when a segment of a point cloud is pickedclass
Holds information when a triangle is pickedclass
Encapsulate a Point Light object in a Qt 3D sceneclass
Specifies the size of rasterized points.class
Sets the scale and steps to calculate depth values for polygon offsetsclass
Select entities which are within a distance threshold of a target entityclass
Render state allows to control the type of rasterization to be performedclass
Qt3DRender::QRayCaster is used to perform ray casting tests in 3d world coordinatesclass
Details of a hit when casting a ray through a modelclass
Classclass
Holds settings related to available rendering enginesclass
Frame graph node for render capturefinal class
Receives the result of render capture requestclass
Encapsulates a Render Passclass
Provides storage for vectors of Filter Keys and Parametersclass
Holds settings related to rendering process and host the active FrameGraphclass
An abstract base class for all render statesclass
FrameGraph node offers a way of specifying a set of QRenderState objects to be applied during the execution of a framegraph branchclass
Provides a way of specifying the render surfaceclass
Encapsulates a target (usually a frame buffer object) which the renderer can render intoclass
Allows the specification of an attachment of a render target (whether it is a color texture, a depth texture, etc...class
Provides a way of specifying a render targetclass
Provides the facility to load an existing Sceneclass
Discards fragments that fall outside of a certain rectangular portion of the screenclass
Performe ray casting test based on screen coordinatesclass
Enables seamless cubemap texture filteringclass
FrameGraphNode used to insert a fence in the graphics command streamclass
Provides a way of specifying values of a Uniform Block or a shader structureclass
Provides Image access to shader programsclass
Encapsulates a Shader Programclass
Generates a Shader Program content from loaded graphsclass
Allows to use a textureId from a separate OpenGL context in a Qt 3D sceneclass
Provides storage for the sort types to be usedclass
Encapsulate a Spot Light object in a Qt 3D sceneclass
Controls the front and back writing of individual bits in the stencil planesclass
Specifies stencil operationfinal class
Sets the actions to be taken when stencil and depth tests failclass
Specifies arguments for the stecil testfinal class
Specifies arguments for stencil testclass
Enables or disables entire subtrees of framegraph nodesclass
Encapsulates a Techniqueclass
A QFrameGraphNode used to select QTechniques to useclass
A QAbstractTexture with a Target1D target formatclass
A QAbstractTexture with a Target1DArray target formatclass
A QAbstractTexture with a Target2D target formatclass
A QAbstractTexture with a Target2DArray target formatclass
A QAbstractTexture with a Target2DMultisample target formatclass
A QAbstractTexture with a Target2DMultisampleArray target formatclass
A QAbstractTexture with a Target3D target formatclass
A QAbstractTexture with a TargetBuffer target formatclass
A QAbstractTexture with a TargetCubeMap target formatclass
A QAbstractTexture with a TargetCubeMapArray target formatclass
Stores texture information such as the target, height, width, depth, layers, wrap, and if mipmaps are enabledclass
Holds content and information required to perform partial updates of a texture contentclass
Encapsulates the necessary information to create an OpenGL texture image from an image sourceclass
Stores data representing a textureclass
Handles the texture loading and setting the texture's propertiesclass
A QAbstractTexture with a TargetRectangle target formatclass
Defines the wrap mode a Qt3DRender::QAbstractTexture should apply to a textureclass
A viewport on the Qt3D Sceneclass
FrameGraphNode used to wait for a fence in the graphics command stream to become signaled -
Uses of QtObjectInterface in io.qt.qt3d.render.quick.scene2d
Modifier and TypeClassDescriptionclass
This class enables rendering qml into a texture, which then can be used as a part of 3D scene -
Uses of QtObjectInterface in io.qt.quick
Modifier and TypeClassDescriptionstatic class
QSGGeometry.VertexData<T extends QtObjectInterface>
Modifier and TypeInterfaceDescriptioninterface
An interface providing access to some of the graphics API specific internals of the scenegraphModifier and TypeClassDescriptionclass
Interface for asynchronous control of QML image requestsclass
Convenience class for integrating OpenGL rendering using a framebuffer object (FBO) with Qt Quickstatic class
Java wrapper for Qt classQQuickFramebufferObject::Renderer
class
Controls lower level graphics settings for the QQuickWindowclass
Opaque container for native graphics objects representing graphics devices or contextsclass
Interface for supporting pixmaps and threaded image requests in QMLclass
Interface for asynchronous image loading in QQuickAsyncImageProviderclass
The most basic of all visual items in Qt Quickstatic final class
Java wrapper for Qt classQQuickItem::UpdatePaintNodeData
final class
Contains the result from QQuickItem::grabToImage()class
Way to use the QPainter API in the QML Scene Graphclass
Mechanism for rendering the Qt Quick scenegraph onto an offscreen render target in a fully application-controlled mannerclass
Opaque container for native graphics resources specifying a render target, and associated metadataclass
Java wrapper for Qt classQQuickRhiItem
class
Java wrapper for Qt classQQuickRhiItemRenderer
class
Access to the QTextDocument of QQuickTextEditclass
Interface for loading custom textures from QMLclass
Java wrapper for Qt classQQuickTransform
class
Window for displaying a Qt Quick user interfaceclass
The window for displaying a graphical QML scenestatic class
Describes some of the RHI's graphics state at the point of a beginExternalCommands() callclass
Serves as a baseclass for geometry based nodesclass
Implements the clipping functionality in the scene graphclass
Serves as a baseclass for dynamically changing textures, such as content that is rendered to FBO'sclass
Convenient way of rendering solid colored geometry in the scene graphclass
Low-level storage for graphics primitives in the Qt Quick Scene Graphstatic class
QSGGeometry::Attribute describes a single vertex attribute in a QSGGeometrystatic class
QSGGeometry::AttributeSet describes how the vertices in a QSGGeometry are built upstatic class
QSGGeometry::ColoredPoint2D struct is a convenience struct for accessing 2D Points with a colorstatic class
QSGGeometry::Point2D struct is a convenience struct for accessing 2D Pointsstatic class
QSGGeometry::TexturedPoint2D struct is a convenience struct for accessing 2D Points with texture coordinatesclass
Used for all rendered content in the scene graphclass
Provided for convenience to easily draw textured content using the QML scene graphclass
Encapsulates rendering state for a shader programclass
Represents a graphics API independent shader programstatic class
Describes state changes that the material wants to apply to the currently active graphics pipeline statestatic class
Encapsulates the current rendering state during a call to QSGMaterialShader::updateUniformData() and the other update type of functionsclass
Used as a unique type token in combination with QSGMaterialclass
Java wrapper for Qt classQSGNinePatchNode
class
The base class for all nodes in the scene graphclass
Java wrapper for Qt classQSGNodeVisitor
class
Used to change opacity of nodesclass
Convenient way of rendering textured geometry in the scene graphclass
Convenience class for drawing solid filled rectangles using scenegraphclass
Represents a set of custom rendering commands targeting the graphics API that is in use by the scenegraphstatic class
Java wrapper for Qt classQSGRenderNode::RenderState
class
Java wrapper for Qt classQSGRootNode
class
Convenience class for drawing solid filled rectangles using scenegraphclass
Provided for convenience to easily draw textured content using the QML scene graphclass
Class for drawing text layouts and text documents in the Qt Quick scene graphclass
The base class for textures used in the scene graphclass
Convenient way of rendering textured geometry in the scene graphclass
Encapsulates texture based entities in QMLclass
Implements transformations in the scene graphclass
Convenient way of rendering per-vertex colored geometry in the scene graphModifier and TypeMethodDescriptionfinal <QNativeInterface extends QtObjectInterface>
QNativeInterfaceQSGTexture.nativeInterface
(Class<QNativeInterface> name) SeeQSGTexture::
resolveInterface(const char*, int)const -
Uses of QtObjectInterface in io.qt.quick.controls
Modifier and TypeClassDescriptionclass
Way to propagate attached properties -
Uses of QtObjectInterface in io.qt.quick.internal
Modifier and TypeClassDescriptionclass
Java wrapper for Qt classQQuickCloseEvent
-
Uses of QtObjectInterface in io.qt.quick.nativeinterface
Modifier and TypeInterfaceDescriptioninterface
Provides access to and enables adopting Direct3D 11 texture objectsinterface
Provides access to and enables adopting Direct3D 12 texture objectsinterface
Provides access to and enables adopting Metal texture objectsinterface
Provides access to and enables adopting OpenGL texture objectsinterface
Provides access to and enables adopting Vulkan image objects -
Uses of QtObjectInterface in io.qt.quick.widgets
Modifier and TypeClassDescriptionclass
Widget for displaying a Qt Quick user interface -
Uses of QtObjectInterface in io.qt.quick3d
Modifier and TypeClassDescriptionclass
Helper class for selecting correct surface formatclass
Base class for defining custom geometrystatic class
Java wrapper for Qt classQQuick3DGeometry::Attribute
static class
Java wrapper for Qt classQQuick3DGeometry::TargetAttribute
class
Base class for defining instance tablesstatic class
Java wrapper for Qt classQQuick3DInstancing::InstanceTableEntry
class
Base class of all 3D nodes and resourcesclass
Abstract class for implementing user side render extensionsclass
Base class for defining custom texture data -
Uses of QtObjectInterface in io.qt.remoteobjects
Modifier and TypeInterfaceDescriptionstatic interface
Java wrapper for Qt callableQRemoteObjectHostBase::RemoteObjectNameFilter
static interface
Java wrapper for Qt callableQRemoteObjectNode::RemoteObjectSchemaHandler
interface
Encapsulates the result of an asynchronous method callModifier and TypeClassDescriptionfinal class
Serves as a convenience class for Replicas of Sources based on QAbstractItemModelclass
Java wrapper for Qt classQConnectionAbstractServer
class
A class which provides the methods for setting PROP values of a replica to value they had the last time the replica was usedfinal class
A dynamically instantiated Replicaclass
A (Host) Node on a Qt Remote Objects networkclass
Base functionality common to Host and RegistryHost classesclass
A node on a Qt Remote Objects networkclass
Provides a QObject-based API for watching a QRemoteObjectPendingCallfinal class
A generic version of QRemoteObjectPendingCall.final class
A class holding information about Source objects available on the Qt Remote Objects networkclass
A (Host/Registry) node on a Qt Remote Objects networkclass
A class interacting with (but not implementing) a Qt API on the Remote Object networkclass
Java wrapper for Qt classQRemoteObjectSettingsStore
class
Java wrapper for Qt classQRemoteObjectSourceLocationInfo
class
Java wrapper for Qt classQtROClientIoDevice
class
Java wrapper for Qt classQtROIoDeviceBase
class
Java wrapper for Qt classQtROServerIoDevice
-
Uses of QtObjectInterface in io.qt.scxml
Modifier and TypeInterfaceDescriptionstatic interface
URI resolver and resource loader for an SCXML compilerstatic interface
Represents a function to be executed on each iteration of an SCXML foreach loopinterface
Used by compiled state machinesModifier and TypeClassDescriptionclass
Compiler for SCXML filesclass
C++ data model for a Qt SCXML state machineclass
The data model base class for a Qt SCXML state machineclass
Creates SCXML service instances from documents loaded at runtimeclass
Describes the errors returned by the Qt SCXML state machine when parsing an SCXML fileclass
Event for a Qt SCXML state machinestatic class
AssingmentInfo class represents a data assignmentstatic class
Represents a unit of executable contentstatic class
Represents a foreach constructstatic class
Represents a service invocationstatic class
Represents a parameter to a service invocationclass
The base class for services called from state machinesclass
Creates invokable service instancesclass
The null data model for a Qt SCXML stateMachineclass
Interface to the state machines created from SCXML filesclass
Creates SCXML service instances from precompiled documents -
Uses of QtObjectInterface in io.qt.sensors
Modifier and TypeInterfaceDescriptioninterface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Java wrapper for Qt classQIRProximityFilter
interface
Java wrapper for Qt classQLidFilter
interface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Convenience wrapper around QSensorFilterinterface
Instantiates instances of QSensorBackendinterface
The pure virtual interface to sensor pluginsinterface
Efficient callback facility for asynchronous notifications of sensor changesinterface
The pure virtual interface to sensor pluginsinterface
Java wrapper for Qt classQTapFilter
interface
Convenience wrapper around QSensorFilterModifier and TypeClassDescriptionclass
Convenience wrapper around QSensorclass
Reports on linear acceleration along the X, Y and Z axesclass
Represents one reading from the ambient light sensorclass
Convenience wrapper around QSensorclass
Holds readings of the ambient temperatureclass
Convenience wrapper around QSensorclass
Convenience wrapper around QSensorclass
Represents one reading from a compassclass
Convenience wrapper around QSensorclass
Represents one reading from the gyroscope sensorclass
Holds readings from the humidity sensorclass
Convenience wrapper around QSensorclass
Java wrapper for Qt classQIRProximityReading
class
Java wrapper for Qt classQIRProximitySensor
class
Java wrapper for Qt classQLidReading
class
Java wrapper for Qt classQLidSensor
class
Represents one reading from the light sensorclass
Convenience wrapper around QSensorclass
Convenience wrapper around QSensorclass
Represents one reading from the magnetometerclass
Represents one reading from the orientation sensorclass
Convenience wrapper around QSensorclass
Holds the specifics of an output rangeclass
Holds readings from the pressure sensorclass
Convenience wrapper around QSensorclass
Represents one reading from the proximity sensorclass
Convenience wrapper around QSensorclass
Represents one reading from the rotation sensorclass
Convenience wrapper around QSensorclass
Represents a single hardware sensorclass
Sensor implementationclass
Handles registration and creation of sensor backendsclass
Holds the readings from the sensorclass
Java wrapper for Qt classQTapReading
class
Java wrapper for Qt classQTapSensor
class
Holds readings from the tilt sensorclass
Convenience wrapper around QSensor -
Uses of QtObjectInterface in io.qt.serialbus
Modifier and TypeInterfaceDescriptioninterface
Factory class used as the plugin interface for CAN bus pluginsstatic interface
Java wrapper for Qt callableQtJambiAPI::FunctionType<int,const QModbusRequest&>::type
static interface
Java wrapper for Qt callableQtJambiAPI::FunctionType<int,const QModbusResponse&>::type
interface
Represents the interface for objects that can be passed to QModbusTcpServer::installConnectionObserverModifier and TypeClassDescriptionfinal class
Handles registration and creation of bus pluginsclass
The interface class for CAN busstatic class
QCanBusDevice::Filter struct defines a filter for CAN bus framesclass
Information about CAN bus interfacesclass
Container class representing a single CAN framestatic class
Timestamp information with microsecond precisionclass
Java wrapper for Qt classQCanDbcFileParser
class
Java wrapper for Qt classQCanFrameProcessor
static class
Java wrapper for Qt classQCanFrameProcessor::ParseResult
class
Java wrapper for Qt classQCanMessageDescription
class
Java wrapper for Qt classQCanSignalDescription
static class
Java wrapper for Qt classQCanSignalDescription::MultiplexValueRange
class
Java wrapper for Qt classQCanUniqueIdDescription
class
The interface to send Modbus requestsclass
Container class representing single bit and 16 bit word entries in the Modbus registerclass
The base class for Modbus classes, QModbusServer and QModbusClientclass
Container class representing the physical and functional description of a Modbus serverclass
Container class containing the function and error code inside a Modbus ADUclass
Abstract container class containing the function code and payload that is stored inside a Modbus ADUclass
Contains the data for a request sent with a QModbusClient derived classclass
Container class containing the function code and payload that is stored inside a Modbus ADUclass
Container class containing the function code and payload that is stored inside a Modbus ADUclass
Represents a Modbus client that uses a serial bus for its communication with the Modbus serverclass
Represents a Modbus server that uses a serial port for its communication with the Modbus clientclass
The interface to receive and process Modbus requestsclass
The interface class for Modbus TCP client deviceclass
Represents a Modbus server that uses a TCP server for its communication with the Modbus client -
Uses of QtObjectInterface in io.qt.serialport
Modifier and TypeClassDescriptionclass
Provides functions to access serial portsclass
Provides information about existing serial ports -
Uses of QtObjectInterface in io.qt.spatialaudio
Modifier and TypeClassDescriptionclass
A stereo overlay soundclass
Manages a three dimensional sound fieldclass
Defines the position and orientation of the person listening to a sound field defined by QAudioEngineclass
Java wrapper for Qt classQAudioRoom
class
A sound object in 3D space -
Uses of QtObjectInterface in io.qt.sql
Modifier and TypeClassDescriptionclass
Handles a connection to a databaseclass
Abstract base class for accessing specific SQL databasesclass
QSqlDriverCreator<T extends QSqlDriver>
The QSqlDriverCreator class is a template class that provides a SQL driver factory for a specific driver type.class
The base class for SQL driver factoriesclass
Abstract base for custom QSqlDriver pluginsclass
SQL database error informationclass
Manipulates the fields in SQL database tables and viewsclass
Functions to manipulate and describe database indexesclass
Means of executing and manipulating SQL statementsclass
Read-only data model for SQL result setsclass
Encapsulates a database recordclass
Stores information about an SQL foreign keyclass
The QSqlRelationalDelegate class provides a delegate that is used to display and edit data from a QSqlRelationalTableModel.class
Editable data model for a single database table, with foreign key supportclass
Abstract interface for accessing data from specific SQL databasesclass
Editable data model for a single database table -
Uses of QtObjectInterface in io.qt.statemachine
Modifier and TypeClassDescriptionclass
The base class of states of a QStateMachineclass
The base class of transitions between QAbstractState objectsclass
QObject-specific transition for Qt eventsclass
Final stateclass
Means of returning to a previously active substateclass
Transition for key eventsclass
Transition for mouse eventsclass
Transition based on a Qt signalclass
General-purpose state for QStateMachineclass
Hierarchical finite state machinestatic class
Represents a Qt signal eventstatic class
Inherits QEvent and holds a clone of an event associated with a QObject -
Uses of QtObjectInterface in io.qt.svg
Modifier and TypeClassDescriptionclass
Paint device that is used to create SVG drawingsclass
Used to draw the contents of SVG files onto paint devices -
Uses of QtObjectInterface in io.qt.test
Modifier and TypeClassDescriptionclass
Helps testing QAbstractItemModel subclassesclass
Enables introspection of signal emissionclass
Java wrapper for Qt classQSpontaneKeyEvent
static class
Java wrapper for Qt classQTest::QBenchmarkIterationController
static class
Used to simulate a sequence of touch eventsstatic final class
Java wrapper for Qt classQTest::QTouchEventWidgetSequence
class
Java wrapper for Qt classQTestDelayEvent
class
Java wrapper for Qt classQTestEvent
class
List of GUI eventsclass
Java wrapper for Qt classQTestEventLoop
class
Java wrapper for Qt classQTestKeyClicksEvent
class
Java wrapper for Qt classQTestKeyEvent
class
Java wrapper for Qt classQTestMouseEvent
-
Uses of QtObjectInterface in io.qt.texttospeech
Modifier and TypeClassDescriptionclass
Convenient access to text-to-speech enginesclass
Java wrapper for Qt classQTextToSpeechEngine
class
Java wrapper for Qt classQTextToSpeechPlugin
class
Represents a particular voice -
Uses of QtObjectInterface in io.qt.webchannel
Modifier and TypeClassDescriptionclass
Exposes QObjects to remote HTML clientsclass
Communication channel between the C++ QWebChannel server and a HTML/JS client -
Uses of QtObjectInterface in io.qt.webchannelquick
-
Uses of QtObjectInterface in io.qt.webengine.core
Modifier and TypeClassDescriptionclass
Information about a certificate errorclass
QWebEngineClientCertSelection class wraps a client certificate selectionfinal class
In-memory store for client certificatesfinal class
Object to customize User-Agent Client Hints used by a profilefinal class
Request for populating or extending a context menu with actionsfinal class
Access to Chromium's cookiesstatic class
QWebEngineCookieStore::FilterRequest struct is used in conjunction with QWebEngineCookieStore::setCookieFilter() and is the type filterCallback operates onclass
A request for populating a dialog with available sources for screen capturingclass
Information about a downloadclass
Enables accepting or rejecting requests for local file system access from JavaScript applicationsclass
Encapsulates the result of a string search on a pagefinal class
Gives information about and control over a page frameclass
Enables accepting or rejecting requests for entering and exiting the fullscreen modefinal class
Represents the history of a web engine pageclass
Represents one item in the history of a web engine pagefinal class
A data model that represents the history of a web engine pageclass
Holds a request to be sent with WebEngineclass
A utility type for the WebEngineView::loadingChanged signalfinal class
A utility type for the QWebEnginePage::navigationRequested signalfinal class
A utility type for the QWebEnginePage::newWindowRequested() signalfinal class
Encapsulates the data of an HTML5 web notificationclass
Object to view and edit web documentsclass
A QWebEnginePermission is an object used to access and modify the state of a single permission that's been granted or denied to a specific origin URLclass
Web engine profile shared by multiple pagesclass
Java wrapper for Qt classQWebEngineQuotaRequest
class
Enables accepting or rejecting requests from the registerProtocolHandler APIclass
Encapsulates a JavaScript programfinal class
Represents a collection of user scriptsfinal class
Object to store the settings used by QWebEnginePagefinal class
Information about URL requestsclass
Abstract base class for URL interceptionfinal class
Represents a custom URL requestclass
Configures a custom URL schemeclass
Base class for handling custom URL schemesclass
Encapsulates the data of a PIN WebAuth UX requestfinal class
Encapsulates the data of a WebAuth UX request -
Uses of QtObjectInterface in io.qt.webengine.quick
Modifier and TypeClassDescriptionclass
Web engine profile shared by multiple pages -
Uses of QtObjectInterface in io.qt.webengine.widgets
Modifier and TypeClassDescriptionclass
Widget that is used to view and edit web documents -
Uses of QtObjectInterface in io.qt.websockets
Modifier and TypeClassDescriptionclass
Abstract base for custom 32-bit mask generatorsclass
Implements a TCP socket that talks the WebSocket protocolclass
Authenticator object for Cross Origin Requests (CORS)class
Collects options for the WebSocket handshakeclass
Implements a WebSocket-based server -
Uses of QtObjectInterface in io.qt.widgets
Modifier and TypeInterfaceDescriptioninterface
The base class for all graphical items in a QGraphicsSceneinterface
Can be inherited to allow your custom items to be managed by layoutsinterface
Abstract base class that must be subclassed when implementing new item editor creatorsinterface
Abstract item that a QLayout manipulatesModifier and TypeClassDescriptionclass
The abstract base class of button widgets, providing functionality common to buttonsclass
Common base for all path itemsclass
Used to display and edit data items from a modelclass
The basic functionality for item view classesclass
Scrolling area with on-demand scroll barsclass
Integer value within a rangeclass
Spinbox and a line edit to display valuesclass
Implements the QAccessibleInterface for QWidgetsclass
Manages the GUI application's control flow and main settingsclass
Lines up child widgets horizontally or verticallyclass
Container to organize groups of button widgetsclass
Monthly based calendar widget allowing the user to select a dateclass
Checkbox with a text labelclass
Dialog widget for specifying colorsclass
Maps device independent QColors to device dependent pixel valuesclass
Model/view implementation of a column viewclass
Combines a button with a dropdown listclass
Vista style command link buttonclass
Encapsulates the common Look and Feel of a GUIclass
Completions based on an item modelclass
Mapping between a section of a data model to widgetsclass
Widget for editing dates based on the QDateTimeEdit widgetclass
Widget for editing dates and timesclass
Rounded range control (like a speedometer or potentiometer)class
The base class of dialog windowsclass
Widget that presents buttons in a layout that is appropriate to the current widget styleclass
Widget that can be docked inside a QMainWindow or floated as a top-level window on the desktopclass
Spin box widget that takes doublesclass
Error message display dialogclass
Dialog that allows users to select files or directoriesclass
File icons for the QFileSystemModel classclass
Focus frame which can be outside of a widget's normal paintable areaclass
Combobox that lets the user select a font familyclass
Dialog widget for selecting a fontclass
Manages forms of input widgets and their associated labelsstatic class
Contains the result of a QFormLayout::takeRow() callclass
The base class of widgets that can have a frameclass
Represents a gesture, containing properties that describe the corresponding user inputclass
The description of triggered gesturesclass
The infrastructure for gesture recognitionfinal class
Represents an anchor between two items in a QGraphicsAnchorLayoutclass
Layout where one can anchor widgets together in Graphics Viewclass
Blur effectclass
Colorize effectclass
Drop shadow effectclass
The base class for all graphics effectsclass
Ellipse item that you can add to a QGraphicsSceneclass
Grid layout for managing widgets in Graphics Viewclass
Java wrapper for Qt classQGraphicsItemAnimation
class
Container that treats a group of items as a single itemclass
The base class for all layouts in Graphics Viewclass
Horizontal or vertical layout for managing widgets in Graphics Viewclass
Line item that you can add to a QGraphicsSceneclass
Base class for all graphics items that require signals, slots and propertiesclass
Opacity effectclass
Path item that you can add to a QGraphicsSceneclass
Pixmap item that you can add to a QGraphicsSceneclass
Polygon item that you can add to a QGraphicsSceneclass
Proxy layer for embedding a QWidget in a QGraphicsSceneclass
Rectangle item that you can add to a QGraphicsSceneclass
Rotation transformation around a given axisclass
Scale transformationclass
Surface for managing a large number of 2D graphical itemsclass
Context menu events in the graphics view frameworkclass
Events for drag and drop in the graphics view frameworkclass
Base class for all graphics view related eventsclass
Events when a tooltip is requestedclass
Hover events in the graphics view frameworkclass
Mouse events in the graphics view frameworkclass
Events for widget moving in the graphics view frameworkclass
Events for widget resizing in the graphics view frameworkclass
Wheel events in the graphics view frameworkclass
Simple text path item that you can add to a QGraphicsSceneclass
Text item that you can add to a QGraphicsScene to display formatted textclass
Abstract base class for building advanced transformations on QGraphicsItemsclass
Widget for displaying the contents of a QGraphicsSceneclass
The base class for all widget items in a QGraphicsSceneclass
Lays out widgets in a gridclass
Group box frame with a titleclass
Lines up widgets horizontallyclass
Header row or header column for item viewsclass
Simple convenience dialog to get a single value from the userclass
Display and editing facilities for data items from a modelclass
QItemEditorCreator<T extends QWidget>
Java wrapper for Qt class QItemEditorCreatorclass
Widgets for editing item data in views and delegatesclass
Allows to input a QKeySequenceclass
Text or image displayclass
The base class of geometry managersclass
Displays a number with LCD-like digitsclass
One-line text editorclass
List or icon view onto a modelclass
Item-based list widgetclass
Item for use with the QListWidget item view classclass
Main application windowclass
Area in which MDI windows are displayedclass
Subwindow class for QMdiAreaclass
Menu widget for use in menu bars, context menus, and other popup menusclass
Horizontal menu barclass
Modal dialog for informing the user or for asking the user a question and receiving an answerclass
Describes a panning gesture made by the userclass
Describes a pinch gesture made by the userclass
Implements a plain text layout for QTextDocumentclass
Widget that is used to edit and display plain textclass
Horizontal or vertical progress barclass
Feedback on the progress of a slow operationclass
Convenience class that simplifies dynamically overriding QStyle elementsclass
Command buttonclass
Radio button with a text labelclass
Java wrapper for Qt classQRhiWidget
class
Rectangle or line that can indicate a selection or a boundaryclass
Scrolling view onto another widgetclass
Vertical or horizontal scroll barfinal class
Enables kinetic scrolling for any scrolling widget or graphics itemclass
Stores the settings for a QScrollerclass
Resize handle for resizing top-level windowsclass
Layout attribute describing horizontal and vertical resizing policyclass
Vertical or horizontal sliderclass
Blank space in a layoutclass
Spin box widgetclass
Splash screen that can be shown during application startupclass
Implements a splitter widgetclass
Handle functionality for the splitterclass
Stack of widgets where only one widget is visible at a timeclass
Stack of widgets where only one widget is visible at a timeclass
QStandardItemEditorCreator<T extends QWidget>
Java wrapper for Qt class QStandardItemEditorCreatorclass
Horizontal bar suitable for presenting status informationclass
Abstract base class that encapsulates the look and feel of a GUIclass
Display and editing facilities for data items from a modelclass
Creates QStyle objectsclass
Style hints that return more than basic data typesclass
Style hints that return a QRegionclass
Style hints that return a QVariantclass
Stores the parameters used by QStyle functionsclass
Used to describe the parameters for drawing buttonsclass
Used to describe the parameter for drawing a comboboxclass
Used to hold parameters that are common to all complex controlsclass
Used to describe the parameters for drawing a dock widgetclass
Used to describe the parameters for drawing a focus rectangle with QStyleclass
Used to describe the parameters for drawing a frameclass
Used to describe the parameters needed to draw a QGraphicsItemclass
Describes the parameters for drawing a group boxclass
Used to describe the parameters for drawing a headerclass
Used to describe the parameters for drawing a headerclass
Used to describe the parameter necessary for drawing a menu itemclass
Used to describe the parameters necessary for drawing a progress barclass
Used to describe the parameters needed for drawing a rubber bandclass
Used to describe the parameter for drawing a size gripclass
Used to describe the parameters needed for drawing a sliderclass
Used to describe the parameters necessary for drawing a spin boxclass
Used to describe the parameters for drawing a tab barclass
Used to describe the base of a tab bar, i.e.class
Used to describe the parameters for drawing the frame around a tab widgetclass
Used to describe the parameters for drawing a title barclass
Used to describe the parameters for drawing a toolbarclass
Used to describe the parameters needed for drawing a tool boxclass
Used to describe the parameters for drawing a tool buttonclass
Used to describe the parameters used to draw an item in a view widgetclass
Convenience class for drawing QStyle elements inside a widgetclass
Abstract base for custom QStyle pluginsclass
Describes a swipe gesture made by the userclass
Icon for an application in the system trayclass
Tab bar, e.g.class
Default model/view implementation of a table viewclass
Item-based table view with a default modelclass
Item for use with the QTableWidget classclass
Way to interact with selection in a model without using model indexes and a selection modelclass
Stack of tabbed widgetsclass
Describes a tap-and-hold (aka LongTap) gesture made by the userclass
Describes a tap gesture made by the userclass
Rich text browser with hypertext navigationclass
Widget that is used to edit and display both plain and rich textstatic class
QTextEdit::ExtraSelection structure provides a way of specifying a character format for a given selection in a documentclass
The rules used to draw a pixmap or image split into nine segmentsclass
Widget for editing times based on the QDateTimeEdit widgetclass
Movable panel that contains a set of controlsclass
Java wrapper for Qt classQToolBarChangeEvent
class
Column of tabbed widget itemsclass
Quick-access button to commands or options, usually used inside a QToolBarfinal class
Tool tips (balloon help) for any widgetclass
Default model/view implementation of a tree viewclass
Tree view that uses a predefined tree modelclass
Item for use with the QTreeWidget convenience classclass
Way to iterate over the items in a QTreeWidget instanceclass
Displays the contents of a QUndoStackclass
Lines up widgets verticallyfinal class
Simple description of any widget, i.e.class
The base class of all user interface objectsclass
Extends QAction by an interface for inserting custom widgets into action based containers, such as toolbarsclass
Layout item that represents a widgetclass
Framework for wizardsclass
The base class for wizard pages -
Uses of QtObjectInterface in io.qt.widgets.svg
Modifier and TypeClassDescriptionclass
QGraphicsItem that can be used to render the contents of SVG filesclass
Widget that is used to display the contents of Scalable Vector Graphics (SVG) files -
Uses of QtObjectInterface in io.qt.widgets.tools
Modifier and TypeClassDescriptionclass
Enables standalone applications to dynamically create user interfaces at run-time using the information stored in UI files or specified in plugin paths -
Uses of QtObjectInterface in io.qt.xml
Modifier and TypeClassDescriptionclass
Represents one attribute of a QDomElementclass
Represents an XML CDATA sectionclass
Represents a generic string in the DOMclass
Represents an XML commentclass
Represents an XML documentstatic class
Struct is used to store the result of QDomDocument::setContent()class
Tree of QDomNodes which is not usually a complete QDomDocumentclass
The representation of the DTD in the document treeclass
Represents one element in the DOM treeclass
Represents an XML entityclass
Represents an XML entity referenceclass
Information about the features of the DOM implementationclass
Contains a collection of nodes that can be accessed by nameclass
The base class for all the nodes in a DOM treeclass
List of QDomNode objectsclass
Represents an XML notationclass
Represents an XML processing instructionclass
Represents text data in the parsed XML document
QProperty
and add a binding to the target