Struct qt_gui::QOpenGLDebugLogger

#[repr(C)]
pub struct QOpenGLDebugLogger { /* fields omitted */ }

The QOpenGLDebugLogger enables logging of OpenGL debugging messages.

C++ class: QOpenGLDebugLogger.

C++ documentation:

The QOpenGLDebugLogger enables logging of OpenGL debugging messages.

Methods

impl QOpenGLDebugLogger

pub fn slot_log_message(&self) -> Receiver<(*const QOpenGLDebugMessage,)>

Inserts the message debugMessage into the OpenGL debug log. This provides a way for applications or libraries to insert custom messages that can ease the debugging of OpenGL applications.

Returns a built-in Qt slot QOpenGLDebugLogger::logMessage that can be passed to qt_core::Signal::connect.

C++ documentation:

Inserts the message debugMessage into the OpenGL debug log. This provides a way for applications or libraries to insert custom messages that can ease the debugging of OpenGL applications.

Note: debugMessage must have QOpenGLDebugMessage::ApplicationSource or QOpenGLDebugMessage::ThirdPartySource as its source, and a valid type and severity, otherwise it will not be inserted into the log.

Note: The object must be initialized before logging can happen.

See also initialize().

pub fn slot_start_logging(&self) -> Receiver<(LoggingMode,)>

Starts logging messages coming from the OpenGL server. When a new message is received, the signal messageLogged() is emitted, carrying the logged message as argument.

Returns a built-in Qt slot QOpenGLDebugLogger::startLogging that can be passed to qt_core::Signal::connect.

C++ documentation:

Starts logging messages coming from the OpenGL server. When a new message is received, the signal messageLogged() is emitted, carrying the logged message as argument.

loggingMode specifies whether the logging must be asynchronous (the default) or synchronous.

QOpenGLDebugLogger will record the values of GL_DEBUG_OUTPUT and GL_DEBUG_OUTPUT_SYNCHRONOUS when logging is started, and set them back when logging is stopped. Moreover, any user-defined OpenGL debug callback installed when this function is invoked will be restored when logging is stopped; QOpenGLDebugLogger will ensure that the pre-existing callback will still be invoked when logging.

Note: It's not possible to change the logging mode without stopping and starting logging again. This might change in a future version of Qt.

Note: The object must be initialized before logging can happen.

See also stopLogging() and initialize().

pub fn slot_stop_logging(&self) -> Receiver<()>

Stops logging messages from the OpenGL server.

Returns a built-in Qt slot QOpenGLDebugLogger::stopLogging that can be passed to qt_core::Signal::connect.

C++ documentation:

Stops logging messages from the OpenGL server.

See also startLogging().

pub fn message_logged(&self) -> Signal<(*const QOpenGLDebugMessage,)>

This signal is emitted when a debug message (wrapped by the debugMessage argument) is logged from the OpenGL server.

Returns a built-in Qt signal QOpenGLDebugLogger::messageLogged that can be passed to qt_core::Signal::connect.

C++ documentation:

This signal is emitted when a debug message (wrapped by the debugMessage argument) is logged from the OpenGL server.

Depending on the OpenGL implementation, this signal can be emitted from other threads than the one(s) the receiver(s) lives in, and even different from the thread the QOpenGLContext in which this object has been initialized lives in. Moreover, the signal could be emitted from multiple threads at the same time. This is normally not a problem, as Qt will utilize a queued connection for cross-thread signal emissions, but if you force the connection type to Direct then you must be aware of the potential races in the slots connected to this signal.

If logging have been started in SynchronousLogging mode, OpenGL guarantees that this signal will be emitted from the same thread the QOpenGLContext has been bound to, and no concurrent invocations will ever happen.

Note: Logging must have been started, or this signal will not be emitted.

See also startLogging().

pub unsafe fn disable_messages_q_flags_source_q_flags_type_q_flags_severity(
    &mut self,
    sources: QFlags<Source>,
    types: QFlags<Type>,
    severities: QFlags<Severity>
)

Disables the logging of messages with the given sources, of the given types and with the given severities and any message id.

Calls C++ function: void QOpenGLDebugLogger::disableMessages(QFlags<QOpenGLDebugMessage::Source> sources = …, QFlags<QOpenGLDebugMessage::Type> types = …, QFlags<QOpenGLDebugMessage::Severity> severities = …).

C++ documentation:

Disables the logging of messages with the given sources, of the given types and with the given severities and any message id.

The logging will be disabled in the current control group.

See also enableMessages(), pushGroup(), and popGroup().

pub unsafe fn disable_messages_q_vector_of_u32_q_flags_source_q_flags_type(
    &mut self,
    ids: impl CastInto<Ref<QVectorOfU32>>,
    sources: QFlags<Source>,
    types: QFlags<Type>
)

Disables the logging of messages with the given ids, from the given sources and of the given types and any severity.

Calls C++ function: void QOpenGLDebugLogger::disableMessages(const QVector<GLuint>& ids, QFlags<QOpenGLDebugMessage::Source> sources = …, QFlags<QOpenGLDebugMessage::Type> types = …).

C++ documentation:

Disables the logging of messages with the given ids, from the given sources and of the given types and any severity.

The logging will be disabled in the current control group.

See also enableMessages(), pushGroup(), and popGroup().

pub unsafe fn disable_messages_q_flags_source_q_flags_type(
    &mut self,
    sources: QFlags<Source>,
    types: QFlags<Type>
)

Disables the logging of messages with the given sources, of the given types and with the given severities and any message id.

Calls C++ function: void QOpenGLDebugLogger::disableMessages(QFlags<QOpenGLDebugMessage::Source> sources = …, QFlags<QOpenGLDebugMessage::Type> types = …).

C++ documentation:

Disables the logging of messages with the given sources, of the given types and with the given severities and any message id.

The logging will be disabled in the current control group.

See also enableMessages(), pushGroup(), and popGroup().

pub unsafe fn disable_messages_q_flags_source(
    &mut self,
    sources: QFlags<Source>
)

Disables the logging of messages with the given sources, of the given types and with the given severities and any message id.

Calls C++ function: void QOpenGLDebugLogger::disableMessages(QFlags<QOpenGLDebugMessage::Source> sources = …).

C++ documentation:

Disables the logging of messages with the given sources, of the given types and with the given severities and any message id.

The logging will be disabled in the current control group.

See also enableMessages(), pushGroup(), and popGroup().

pub unsafe fn disable_messages(&mut self)

Disables the logging of messages with the given sources, of the given types and with the given severities and any message id.

Calls C++ function: void QOpenGLDebugLogger::disableMessages().

C++ documentation:

Disables the logging of messages with the given sources, of the given types and with the given severities and any message id.

The logging will be disabled in the current control group.

See also enableMessages(), pushGroup(), and popGroup().

pub unsafe fn disable_messages_q_vector_of_u32_q_flags_source(
    &mut self,
    ids: impl CastInto<Ref<QVectorOfU32>>,
    sources: QFlags<Source>
)

Disables the logging of messages with the given ids, from the given sources and of the given types and any severity.

Calls C++ function: void QOpenGLDebugLogger::disableMessages(const QVector<GLuint>& ids, QFlags<QOpenGLDebugMessage::Source> sources = …).

C++ documentation:

Disables the logging of messages with the given ids, from the given sources and of the given types and any severity.

The logging will be disabled in the current control group.

See also enableMessages(), pushGroup(), and popGroup().

pub unsafe fn disable_messages_q_vector_of_u32(
    &mut self,
    ids: impl CastInto<Ref<QVectorOfU32>>
)

Disables the logging of messages with the given ids, from the given sources and of the given types and any severity.

Calls C++ function: void QOpenGLDebugLogger::disableMessages(const QVector<GLuint>& ids).

C++ documentation:

Disables the logging of messages with the given ids, from the given sources and of the given types and any severity.

The logging will be disabled in the current control group.

See also enableMessages(), pushGroup(), and popGroup().

pub unsafe fn enable_messages_q_flags_source_q_flags_type_q_flags_severity(
    &mut self,
    sources: QFlags<Source>,
    types: QFlags<Type>,
    severities: QFlags<Severity>
)

Enables the logging of messages from the given sources, of the given types and with the given severities and any message id.

Calls C++ function: void QOpenGLDebugLogger::enableMessages(QFlags<QOpenGLDebugMessage::Source> sources = …, QFlags<QOpenGLDebugMessage::Type> types = …, QFlags<QOpenGLDebugMessage::Severity> severities = …).

C++ documentation:

Enables the logging of messages from the given sources, of the given types and with the given severities and any message id.

The logging will be enabled in the current control group.

See also disableMessages(), pushGroup(), and popGroup().

pub unsafe fn enable_messages_q_vector_of_u32_q_flags_source_q_flags_type(
    &mut self,
    ids: impl CastInto<Ref<QVectorOfU32>>,
    sources: QFlags<Source>,
    types: QFlags<Type>
)

Enables the logging of messages with the given ids, from the given sources and of the given types and any severity.

Calls C++ function: void QOpenGLDebugLogger::enableMessages(const QVector<GLuint>& ids, QFlags<QOpenGLDebugMessage::Source> sources = …, QFlags<QOpenGLDebugMessage::Type> types = …).

C++ documentation:

Enables the logging of messages with the given ids, from the given sources and of the given types and any severity.

The logging will be enabled in the current control group.

See also disableMessages(), pushGroup(), and popGroup().

pub unsafe fn enable_messages_q_flags_source_q_flags_type(
    &mut self,
    sources: QFlags<Source>,
    types: QFlags<Type>
)

Enables the logging of messages from the given sources, of the given types and with the given severities and any message id.

Calls C++ function: void QOpenGLDebugLogger::enableMessages(QFlags<QOpenGLDebugMessage::Source> sources = …, QFlags<QOpenGLDebugMessage::Type> types = …).

C++ documentation:

Enables the logging of messages from the given sources, of the given types and with the given severities and any message id.

The logging will be enabled in the current control group.

See also disableMessages(), pushGroup(), and popGroup().

pub unsafe fn enable_messages_q_flags_source(&mut self, sources: QFlags<Source>)

Enables the logging of messages from the given sources, of the given types and with the given severities and any message id.

Calls C++ function: void QOpenGLDebugLogger::enableMessages(QFlags<QOpenGLDebugMessage::Source> sources = …).

C++ documentation:

Enables the logging of messages from the given sources, of the given types and with the given severities and any message id.

The logging will be enabled in the current control group.

See also disableMessages(), pushGroup(), and popGroup().

pub unsafe fn enable_messages(&mut self)

Enables the logging of messages from the given sources, of the given types and with the given severities and any message id.

Calls C++ function: void QOpenGLDebugLogger::enableMessages().

C++ documentation:

Enables the logging of messages from the given sources, of the given types and with the given severities and any message id.

The logging will be enabled in the current control group.

See also disableMessages(), pushGroup(), and popGroup().

pub unsafe fn enable_messages_q_vector_of_u32_q_flags_source(
    &mut self,
    ids: impl CastInto<Ref<QVectorOfU32>>,
    sources: QFlags<Source>
)

Enables the logging of messages with the given ids, from the given sources and of the given types and any severity.

Calls C++ function: void QOpenGLDebugLogger::enableMessages(const QVector<GLuint>& ids, QFlags<QOpenGLDebugMessage::Source> sources = …).

C++ documentation:

Enables the logging of messages with the given ids, from the given sources and of the given types and any severity.

The logging will be enabled in the current control group.

See also disableMessages(), pushGroup(), and popGroup().

pub unsafe fn enable_messages_q_vector_of_u32(
    &mut self,
    ids: impl CastInto<Ref<QVectorOfU32>>
)

Enables the logging of messages with the given ids, from the given sources and of the given types and any severity.

Calls C++ function: void QOpenGLDebugLogger::enableMessages(const QVector<GLuint>& ids).

C++ documentation:

Enables the logging of messages with the given ids, from the given sources and of the given types and any severity.

The logging will be enabled in the current control group.

See also disableMessages(), pushGroup(), and popGroup().

pub unsafe fn initialize(&mut self) -> bool

Initializes the object in the current OpenGL context. The context must support the GL_KHR_debug extension for the initialization to succeed. The object must be initialized before any logging can happen.

Calls C++ function: bool QOpenGLDebugLogger::initialize().

C++ documentation:

Initializes the object in the current OpenGL context. The context must support the GL_KHR_debug extension for the initialization to succeed. The object must be initialized before any logging can happen.

It is safe to call this function multiple times from the same context.

This function can also be used to change the context of a previously initialized object; note that in this case the object must not be logging when you call this function.

Returns true if the logger is successfully initialized; false otherwise.

See also QOpenGLContext.

pub unsafe fn is_logging(&self) -> bool

Returns true if this object is currently logging, false otherwise.

Calls C++ function: bool QOpenGLDebugLogger::isLogging() const.

C++ documentation:

Returns true if this object is currently logging, false otherwise.

See also startLogging().

pub unsafe fn log_message(
    &mut self,
    debug_message: impl CastInto<Ref<QOpenGLDebugMessage>>
)

Inserts the message debugMessage into the OpenGL debug log. This provides a way for applications or libraries to insert custom messages that can ease the debugging of OpenGL applications.

Calls C++ function: [slot] void QOpenGLDebugLogger::logMessage(const QOpenGLDebugMessage& debugMessage).

C++ documentation:

Inserts the message debugMessage into the OpenGL debug log. This provides a way for applications or libraries to insert custom messages that can ease the debugging of OpenGL applications.

Note: debugMessage must have QOpenGLDebugMessage::ApplicationSource or QOpenGLDebugMessage::ThirdPartySource as its source, and a valid type and severity, otherwise it will not be inserted into the log.

Note: The object must be initialized before logging can happen.

See also initialize().

pub unsafe fn logged_messages(&self) -> CppBox<QListOfQOpenglDebugMessage>

Reads all the available messages in the OpenGL internal debug log and returns them. Moreover, this function will clear the internal debug log, so that subsequent invocations will not return messages that were already returned.

Calls C++ function: QList<QOpenGLDebugMessage> QOpenGLDebugLogger::loggedMessages() const.

C++ documentation:

Reads all the available messages in the OpenGL internal debug log and returns them. Moreover, this function will clear the internal debug log, so that subsequent invocations will not return messages that were already returned.

See also startLogging().

pub unsafe fn logging_mode(&self) -> LoggingMode

This property holds the logging mode passed to startLogging().

Calls C++ function: QOpenGLDebugLogger::LoggingMode QOpenGLDebugLogger::loggingMode() const.

C++ documentation:

This property holds the logging mode passed to startLogging().

Note that logging must have been started or the value of this property will be meaningless.

Access functions:

LoggingMode

loggingMode() const

See also startLogging() and isLogging().

pub unsafe fn maximum_message_length(&self) -> i64

Returns the maximum supported length, in bytes, for the text of the messages passed to logMessage(). This is also the maximum length of a debug group name, as pushing or popping groups will automatically log a message with the debug group name as the message text.

Calls C++ function: qint64 QOpenGLDebugLogger::maximumMessageLength() const.

C++ documentation:

Returns the maximum supported length, in bytes, for the text of the messages passed to logMessage(). This is also the maximum length of a debug group name, as pushing or popping groups will automatically log a message with the debug group name as the message text.

If a message text is too long, it will be automatically truncated by QOpenGLDebugLogger.

Note: Message texts are encoded in UTF-8 when they get passed to OpenGL, so their size in bytes does not usually match the amount of UTF-16 code units, as returned f.i. by QString::length(). (It does if the message contains 7-bit ASCII only data, which is typical for debug messages.)

pub unsafe fn meta_object(&self) -> Ptr<QMetaObject>

Calls C++ function: virtual const QMetaObject* QOpenGLDebugLogger::metaObject() const.

pub unsafe fn new_1a(
    parent: impl CastInto<MutPtr<QObject>>
) -> CppBox<QOpenGLDebugLogger>

Constructs a new logger object with the given parent.

Calls C++ function: [constructor] void QOpenGLDebugLogger::QOpenGLDebugLogger(QObject* parent = …).

C++ documentation:

Constructs a new logger object with the given parent.

Note: The object must be initialized before logging can happen.

See also initialize().

pub unsafe fn new_0a() -> CppBox<QOpenGLDebugLogger>

The QOpenGLDebugLogger enables logging of OpenGL debugging messages.

Calls C++ function: [constructor] void QOpenGLDebugLogger::QOpenGLDebugLogger().

C++ documentation:

The QOpenGLDebugLogger enables logging of OpenGL debugging messages.

pub unsafe fn pop_group(&mut self)

Pops the topmost debug group from the debug groups stack. If the group is successfully popped, OpenGL will automatically log a message with message, id and source matching those of the popped group, type QOpenGLDebugMessage::GroupPopType and severity QOpenGLDebugMessage::NotificationSeverity.

Calls C++ function: void QOpenGLDebugLogger::popGroup().

C++ documentation:

Pops the topmost debug group from the debug groups stack. If the group is successfully popped, OpenGL will automatically log a message with message, id and source matching those of the popped group, type QOpenGLDebugMessage::GroupPopType and severity QOpenGLDebugMessage::NotificationSeverity.

Popping a debug group will restore the message filtering settings of the group that becomes the top of the debug groups stack.

Note: The object must be initialized before managing debug groups.

See also pushGroup().

pub unsafe fn push_group_3a(
    &mut self,
    name: impl CastInto<Ref<QString>>,
    id: u32,
    source: Source
)

Pushes a debug group with name name, id id, and source source onto the debug groups stack. If the group is successfully pushed, OpenGL will automatically log a message with message name, id id, source source, type QOpenGLDebugMessage::GroupPushType and severity QOpenGLDebugMessage::NotificationSeverity.

Calls C++ function: void QOpenGLDebugLogger::pushGroup(const QString& name, GLuint id = …, QOpenGLDebugMessage::Source source = …).

C++ documentation:

Pushes a debug group with name name, id id, and source source onto the debug groups stack. If the group is successfully pushed, OpenGL will automatically log a message with message name, id id, source source, type QOpenGLDebugMessage::GroupPushType and severity QOpenGLDebugMessage::NotificationSeverity.

The newly pushed group will inherit the same filtering settings of the group that was on the top of the stack; that is, the filtering will not be changed by pushing a new group.

Note: The source must either be QOpenGLDebugMessage::ApplicationSource or QOpenGLDebugMessage::ThirdPartySource, otherwise the group will not be pushed.

Note: The object must be initialized before managing debug groups.

See also popGroup(), enableMessages(), and disableMessages().

pub unsafe fn push_group_2a(
    &mut self,
    name: impl CastInto<Ref<QString>>,
    id: u32
)

Pushes a debug group with name name, id id, and source source onto the debug groups stack. If the group is successfully pushed, OpenGL will automatically log a message with message name, id id, source source, type QOpenGLDebugMessage::GroupPushType and severity QOpenGLDebugMessage::NotificationSeverity.

Calls C++ function: void QOpenGLDebugLogger::pushGroup(const QString& name, GLuint id = …).

C++ documentation:

Pushes a debug group with name name, id id, and source source onto the debug groups stack. If the group is successfully pushed, OpenGL will automatically log a message with message name, id id, source source, type QOpenGLDebugMessage::GroupPushType and severity QOpenGLDebugMessage::NotificationSeverity.

The newly pushed group will inherit the same filtering settings of the group that was on the top of the stack; that is, the filtering will not be changed by pushing a new group.

Note: The source must either be QOpenGLDebugMessage::ApplicationSource or QOpenGLDebugMessage::ThirdPartySource, otherwise the group will not be pushed.

Note: The object must be initialized before managing debug groups.

See also popGroup(), enableMessages(), and disableMessages().

pub unsafe fn push_group_1a(&mut self, name: impl CastInto<Ref<QString>>)

Pushes a debug group with name name, id id, and source source onto the debug groups stack. If the group is successfully pushed, OpenGL will automatically log a message with message name, id id, source source, type QOpenGLDebugMessage::GroupPushType and severity QOpenGLDebugMessage::NotificationSeverity.

Calls C++ function: void QOpenGLDebugLogger::pushGroup(const QString& name).

C++ documentation:

Pushes a debug group with name name, id id, and source source onto the debug groups stack. If the group is successfully pushed, OpenGL will automatically log a message with message name, id id, source source, type QOpenGLDebugMessage::GroupPushType and severity QOpenGLDebugMessage::NotificationSeverity.

The newly pushed group will inherit the same filtering settings of the group that was on the top of the stack; that is, the filtering will not be changed by pushing a new group.

Note: The source must either be QOpenGLDebugMessage::ApplicationSource or QOpenGLDebugMessage::ThirdPartySource, otherwise the group will not be pushed.

Note: The object must be initialized before managing debug groups.

See also popGroup(), enableMessages(), and disableMessages().

pub unsafe fn qt_metacall(
    &mut self,
    arg1: Call,
    arg2: c_int,
    arg3: impl CastInto<MutPtr<*mut c_void>>
) -> c_int

Calls C++ function: virtual int QOpenGLDebugLogger::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3).

pub unsafe fn qt_metacast(
    &mut self,
    arg1: impl CastInto<Ptr<c_char>>
) -> MutPtr<c_void>

Calls C++ function: virtual void* QOpenGLDebugLogger::qt_metacast(const char* arg1).

pub unsafe fn start_logging_1a(&mut self, logging_mode: LoggingMode)

Starts logging messages coming from the OpenGL server. When a new message is received, the signal messageLogged() is emitted, carrying the logged message as argument.

Calls C++ function: [slot] void QOpenGLDebugLogger::startLogging(QOpenGLDebugLogger::LoggingMode loggingMode = …).

C++ documentation:

Starts logging messages coming from the OpenGL server. When a new message is received, the signal messageLogged() is emitted, carrying the logged message as argument.

loggingMode specifies whether the logging must be asynchronous (the default) or synchronous.

QOpenGLDebugLogger will record the values of GL_DEBUG_OUTPUT and GL_DEBUG_OUTPUT_SYNCHRONOUS when logging is started, and set them back when logging is stopped. Moreover, any user-defined OpenGL debug callback installed when this function is invoked will be restored when logging is stopped; QOpenGLDebugLogger will ensure that the pre-existing callback will still be invoked when logging.

Note: It's not possible to change the logging mode without stopping and starting logging again. This might change in a future version of Qt.

Note: The object must be initialized before logging can happen.

See also stopLogging() and initialize().

pub unsafe fn start_logging_0a(&mut self)

Starts logging messages coming from the OpenGL server. When a new message is received, the signal messageLogged() is emitted, carrying the logged message as argument.

Calls C++ function: [slot] void QOpenGLDebugLogger::startLogging().

C++ documentation:

Starts logging messages coming from the OpenGL server. When a new message is received, the signal messageLogged() is emitted, carrying the logged message as argument.

loggingMode specifies whether the logging must be asynchronous (the default) or synchronous.

QOpenGLDebugLogger will record the values of GL_DEBUG_OUTPUT and GL_DEBUG_OUTPUT_SYNCHRONOUS when logging is started, and set them back when logging is stopped. Moreover, any user-defined OpenGL debug callback installed when this function is invoked will be restored when logging is stopped; QOpenGLDebugLogger will ensure that the pre-existing callback will still be invoked when logging.

Note: It's not possible to change the logging mode without stopping and starting logging again. This might change in a future version of Qt.

Note: The object must be initialized before logging can happen.

See also stopLogging() and initialize().

pub unsafe fn static_meta_object() -> Ref<QMetaObject>

Returns a reference to the staticMetaObject field.

pub unsafe fn stop_logging(&mut self)

Stops logging messages from the OpenGL server.

Calls C++ function: [slot] void QOpenGLDebugLogger::stopLogging().

C++ documentation:

Stops logging messages from the OpenGL server.

See also startLogging().

pub unsafe fn tr(
    s: impl CastInto<Ptr<c_char>>,
    c: impl CastInto<Ptr<c_char>>,
    n: c_int
) -> CppBox<QString>

Calls C++ function: static QString QOpenGLDebugLogger::tr(const char* s, const char* c, int n).

pub unsafe fn tr_utf8(
    s: impl CastInto<Ptr<c_char>>,
    c: impl CastInto<Ptr<c_char>>,
    n: c_int
) -> CppBox<QString>

Calls C++ function: static QString QOpenGLDebugLogger::trUtf8(const char* s, const char* c, int n).

Trait Implementations

impl CppDeletable for QOpenGLDebugLogger

unsafe fn delete(&mut self)

Destroys the logger object.

Calls C++ function: virtual [destructor] void QOpenGLDebugLogger::~QOpenGLDebugLogger().

C++ documentation:

Destroys the logger object.

impl Deref for QOpenGLDebugLogger

type Target = QObject

The resulting type after dereferencing.

fn deref(&self) -> &QObject

Calls C++ function: QObject* static_cast<QObject*>(QOpenGLDebugLogger* ptr).

impl DerefMut for QOpenGLDebugLogger

fn deref_mut(&mut self) -> &mut QObject

Calls C++ function: QObject* static_cast<QObject*>(QOpenGLDebugLogger* ptr).

impl DynamicCast<QOpenGLDebugLogger> for QObject

unsafe fn dynamic_cast(ptr: Ptr<QObject>) -> Ptr<QOpenGLDebugLogger>

Calls C++ function: QOpenGLDebugLogger* dynamic_cast<QOpenGLDebugLogger*>(QObject* ptr).

unsafe fn dynamic_cast_mut(ptr: MutPtr<QObject>) -> MutPtr<QOpenGLDebugLogger>

Calls C++ function: QOpenGLDebugLogger* dynamic_cast<QOpenGLDebugLogger*>(QObject* ptr).

impl StaticDowncast<QOpenGLDebugLogger> for QObject

unsafe fn static_downcast(ptr: Ptr<QObject>) -> Ptr<QOpenGLDebugLogger>

Calls C++ function: QOpenGLDebugLogger* static_cast<QOpenGLDebugLogger*>(QObject* ptr).

unsafe fn static_downcast_mut(
    ptr: MutPtr<QObject>
) -> MutPtr<QOpenGLDebugLogger>

Calls C++ function: QOpenGLDebugLogger* static_cast<QOpenGLDebugLogger*>(QObject* ptr).

impl StaticUpcast<QObject> for QOpenGLDebugLogger

unsafe fn static_upcast(ptr: Ptr<QOpenGLDebugLogger>) -> Ptr<QObject>

Calls C++ function: QObject* static_cast<QObject*>(QOpenGLDebugLogger* ptr).

unsafe fn static_upcast_mut(ptr: MutPtr<QOpenGLDebugLogger>) -> MutPtr<QObject>

Calls C++ function: QObject* static_cast<QObject*>(QOpenGLDebugLogger* ptr).