/// C++ type: <span style='color: green;'>```QOpenGLDebugLogger::LoggingMode```</span>
///
/// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#LoggingMode-enum">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The LoggingMode enum defines the logging mode of the logger object.</p></div>
#[derive(Debug, PartialEq, Eq, Clone)]
#[repr(C)]
pub enum LoggingMode {
  /// Messages from the OpenGL server are logged asynchronously. This means that messages can be logged some time after the corresponding OpenGL actions that caused them, and even be received in an out-of-order fashion, depending on the OpenGL implementation. This mode has a very low performance penalty, as OpenGL implementations are heavily threaded and asynchronous by nature. (C++ enum variant: <span style='color: green;'>```AsynchronousLogging = 0```</span>)
  Asynchronous = 0,
  /// Messages from the OpenGL server are logged synchronously and sequentially. This has a severe performance hit, as OpenGL implementations are very asynchronous by nature; but it's very useful to debug OpenGL problems, as OpenGL guarantees that the messages generated by a OpenGL command will be logged before the corresponding command execution has returned. Therefore, you can install a breakpoint on the <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#messageLogged">messageLogged</a>() signal and see in the backtrace which OpenGL command caused it; the only caveat is that if you are using OpenGL from multiple threads you may need to force direct connection when connecting to the <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#messageLogged">messageLogged</a>() signal. (C++ enum variant: <span style='color: green;'>```SynchronousLogging = 1```</span>)
  Synchronous = 1,
}

/// C++ type: <span style='color: green;'>```QOpenGLDebugLogger```</span>
///
/// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html">QOpenGLDebugLogger</a> enables logging of OpenGL debugging messages.</p>
/// <a name="introduction"></a></div>
#[repr(C)]
pub struct OpenGLDebugLogger(u8);

impl OpenGLDebugLogger {
  /// C++ method: <span style='color: green;'>```QOpenGLDebugLogger::disableMessages```</span>
  ///
  /// This is an overloaded function. Available variants:
  ///
  ///
  ///
  /// ## Variant 1
  ///
  /// Rust arguments: ```fn disable_messages(&mut self, ()) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::disableMessages()```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Disables the logging of messages with the given <i>sources</i>, of the given <i>types</i> and with the given <i>severities</i> and any message id.</p>
  /// <p>The logging will be disabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 2
  ///
  /// Rust arguments: ```fn disable_messages(&mut self, ::qt_core::flags::Flags<::opengl_debug_message::Source>) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::disableMessages(QFlags<QOpenGLDebugMessage::Source> sources = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Disables the logging of messages with the given <i>sources</i>, of the given <i>types</i> and with the given <i>severities</i> and any message id.</p>
  /// <p>The logging will be disabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 3
  ///
  /// Rust arguments: ```fn disable_messages(&mut self, (::qt_core::flags::Flags<::opengl_debug_message::Source>, ::qt_core::flags::Flags<::opengl_debug_message::Type>)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::disableMessages(QFlags<QOpenGLDebugMessage::Source> sources = ?, QFlags<QOpenGLDebugMessage::Type> types = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Disables the logging of messages with the given <i>sources</i>, of the given <i>types</i> and with the given <i>severities</i> and any message id.</p>
  /// <p>The logging will be disabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 4
  ///
  /// Rust arguments: ```fn disable_messages(&mut self, (::qt_core::flags::Flags<::opengl_debug_message::Source>, ::qt_core::flags::Flags<::opengl_debug_message::Type>, ::qt_core::flags::Flags<::opengl_debug_message::Severity>)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::disableMessages(QFlags<QOpenGLDebugMessage::Source> sources = ?, QFlags<QOpenGLDebugMessage::Type> types = ?, QFlags<QOpenGLDebugMessage::Severity> severities = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Disables the logging of messages with the given <i>sources</i>, of the given <i>types</i> and with the given <i>severities</i> and any message id.</p>
  /// <p>The logging will be disabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 5
  ///
  /// Rust arguments: ```fn disable_messages(&mut self, &::vector::VectorU32) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::disableMessages(const QVector<GLuint>& ids)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages-1">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Disables the logging of messages with the given <i>ids</i>, from the given <i>sources</i> and of the given <i>types</i> and any severity.</p>
  /// <p>The logging will be disabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 6
  ///
  /// Rust arguments: ```fn disable_messages(&mut self, (&::vector::VectorU32, ::qt_core::flags::Flags<::opengl_debug_message::Source>)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::disableMessages(const QVector<GLuint>& ids, QFlags<QOpenGLDebugMessage::Source> sources = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages-1">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Disables the logging of messages with the given <i>ids</i>, from the given <i>sources</i> and of the given <i>types</i> and any severity.</p>
  /// <p>The logging will be disabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 7
  ///
  /// Rust arguments: ```fn disable_messages(&mut self, (&::vector::VectorU32, ::qt_core::flags::Flags<::opengl_debug_message::Source>, ::qt_core::flags::Flags<::opengl_debug_message::Type>)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::disableMessages(const QVector<GLuint>& ids, QFlags<QOpenGLDebugMessage::Source> sources = ?, QFlags<QOpenGLDebugMessage::Type> types = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages-1">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Disables the logging of messages with the given <i>ids</i>, from the given <i>sources</i> and of the given <i>types</i> and any severity.</p>
  /// <p>The logging will be disabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  pub fn disable_messages<'largs, Args>(&'largs mut self, args: Args) -> ()
    where Args: overloading::OpenGLDebugLoggerDisableMessagesArgs<'largs>
  {
    args.exec(self)
  }
  /// C++ method: <span style='color: green;'>```QOpenGLDebugLogger::enableMessages```</span>
  ///
  /// This is an overloaded function. Available variants:
  ///
  ///
  ///
  /// ## Variant 1
  ///
  /// Rust arguments: ```fn enable_messages(&mut self, ()) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::enableMessages()```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables the logging of messages from the given <i>sources</i>, of the given <i>types</i> and with the given <i>severities</i> and any message id.</p>
  /// <p>The logging will be enabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 2
  ///
  /// Rust arguments: ```fn enable_messages(&mut self, ::qt_core::flags::Flags<::opengl_debug_message::Source>) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::enableMessages(QFlags<QOpenGLDebugMessage::Source> sources = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables the logging of messages from the given <i>sources</i>, of the given <i>types</i> and with the given <i>severities</i> and any message id.</p>
  /// <p>The logging will be enabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 3
  ///
  /// Rust arguments: ```fn enable_messages(&mut self, (::qt_core::flags::Flags<::opengl_debug_message::Source>, ::qt_core::flags::Flags<::opengl_debug_message::Type>)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::enableMessages(QFlags<QOpenGLDebugMessage::Source> sources = ?, QFlags<QOpenGLDebugMessage::Type> types = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables the logging of messages from the given <i>sources</i>, of the given <i>types</i> and with the given <i>severities</i> and any message id.</p>
  /// <p>The logging will be enabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 4
  ///
  /// Rust arguments: ```fn enable_messages(&mut self, (::qt_core::flags::Flags<::opengl_debug_message::Source>, ::qt_core::flags::Flags<::opengl_debug_message::Type>, ::qt_core::flags::Flags<::opengl_debug_message::Severity>)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::enableMessages(QFlags<QOpenGLDebugMessage::Source> sources = ?, QFlags<QOpenGLDebugMessage::Type> types = ?, QFlags<QOpenGLDebugMessage::Severity> severities = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables the logging of messages from the given <i>sources</i>, of the given <i>types</i> and with the given <i>severities</i> and any message id.</p>
  /// <p>The logging will be enabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 5
  ///
  /// Rust arguments: ```fn enable_messages(&mut self, &::vector::VectorU32) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::enableMessages(const QVector<GLuint>& ids)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages-1">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables the logging of messages with the given <i>ids</i>, from the given <i>sources</i> and of the given <i>types</i> and any severity.</p>
  /// <p>The logging will be enabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 6
  ///
  /// Rust arguments: ```fn enable_messages(&mut self, (&::vector::VectorU32, ::qt_core::flags::Flags<::opengl_debug_message::Source>)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::enableMessages(const QVector<GLuint>& ids, QFlags<QOpenGLDebugMessage::Source> sources = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages-1">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables the logging of messages with the given <i>ids</i>, from the given <i>sources</i> and of the given <i>types</i> and any severity.</p>
  /// <p>The logging will be enabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  ///
  /// ## Variant 7
  ///
  /// Rust arguments: ```fn enable_messages(&mut self, (&::vector::VectorU32, ::qt_core::flags::Flags<::opengl_debug_message::Source>, ::qt_core::flags::Flags<::opengl_debug_message::Type>)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::enableMessages(const QVector<GLuint>& ids, QFlags<QOpenGLDebugMessage::Source> sources = ?, QFlags<QOpenGLDebugMessage::Type> types = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages-1">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables the logging of messages with the given <i>ids</i>, from the given <i>sources</i> and of the given <i>types</i> and any severity.</p>
  /// <p>The logging will be enabled in the current control group.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>().</p></div>
  pub fn enable_messages<'largs, Args>(&'largs mut self, args: Args) -> ()
    where Args: overloading::OpenGLDebugLoggerEnableMessagesArgs<'largs>
  {
    args.exec(self)
  }
  /// C++ method: <span style='color: green;'>```bool QOpenGLDebugLogger::initialize()```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#initialize">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Initializes the object in the current OpenGL context. The context must support the <code>GL_KHR_debug</code> extension for the initialization to succeed. The object must be initialized before any logging can happen.</p>
  /// <p>It is safe to call this function multiple times from the same context.</p>
  /// <p>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.</p>
  /// <p>Returns <code>true</code> if the logger is successfully initialized; false otherwise.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopenglcontext.html">QOpenGLContext</a>.</p></div>
  pub fn initialize(&mut self) -> bool {
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_initialize(self as *mut ::opengl_debug_logger::OpenGLDebugLogger) }
  }

  /// C++ method: <span style='color: green;'>```bool QOpenGLDebugLogger::isLogging() const```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#isLogging">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if this object is currently logging, false otherwise.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#startLogging">startLogging</a>().</p></div>
  pub fn is_logging(&self) -> bool {
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_isLogging(self as *const ::opengl_debug_logger::OpenGLDebugLogger) }
  }

  /// C++ method: <span style='color: green;'>```[slot] void QOpenGLDebugLogger::logMessage(const QOpenGLDebugMessage& debugMessage)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#logMessage">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts the message <i>debugMessage</i> 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.</p>
  /// <p><b>Note: </b><i>debugMessage</i> must have <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Source-enum">QOpenGLDebugMessage::ApplicationSource</a> or <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Source-enum">QOpenGLDebugMessage::ThirdPartySource</a> as its source, and a valid type and severity, otherwise it will not be inserted into the log.</p><p><b>Note: </b>The object must be initialized before logging can happen.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#initialize">initialize</a>().</p></div>
  pub fn log_message(&mut self, debug_message: &::opengl_debug_message::OpenGLDebugMessage) {
    unsafe {
      ::ffi::qt_gui_c_QOpenGLDebugLogger_logMessage(self as *mut ::opengl_debug_logger::OpenGLDebugLogger, debug_message as *const ::opengl_debug_message::OpenGLDebugMessage)
    }
  }

  /// C++ method: <span style='color: green;'>```QList<QOpenGLDebugMessage> QOpenGLDebugLogger::loggedMessages() const```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#loggedMessages">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>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.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#startLogging">startLogging</a>().</p></div>
  pub fn logged_messages(&self) -> ::list::ListOpenglDebugMessage {
    {
      let mut object: ::list::ListOpenglDebugMessage =
        unsafe { ::cpp_utils::new_uninitialized::NewUninitialized::new_uninitialized() };
      unsafe {
        ::ffi::qt_gui_c_QOpenGLDebugLogger_loggedMessages_to_output(self as *const ::opengl_debug_logger::OpenGLDebugLogger, &mut object);
      }
      object
    }
  }

  /// C++ method: <span style='color: green;'>```QOpenGLDebugLogger::LoggingMode QOpenGLDebugLogger::loggingMode() const```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#loggingMode-prop">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This property holds the logging mode passed to startLogging().</p>
  /// <p>Note that logging must have been started or the value of this property will be meaningless.</p>
  /// <p><b>Access functions:</b></p>
  /// <div class="table"><table class="alignedsummary">
  /// <tbody><tr><td class="memItemLeft topAlign rightAlign"> LoggingMode </td><td class="memItemRight bottomAlign"><span class="name"><b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#loggingMode">loggingMode</a></b></span>() const</td></tr>
  /// </tbody></table></div>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#startLogging">startLogging</a>() and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#isLogging">isLogging</a>().</p></div>
  pub fn logging_mode(&self) -> ::opengl_debug_logger::LoggingMode {
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_loggingMode(self as *const ::opengl_debug_logger::OpenGLDebugLogger) }
  }

  /// C++ method: <span style='color: green;'>```qint64 QOpenGLDebugLogger::maximumMessageLength() const```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#maximumMessageLength">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the maximum supported length, in bytes, for the text of the messages passed to <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#logMessage">logMessage</a>(). 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.</p>
  /// <p>If a message text is too long, it will be automatically truncated by <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html">QOpenGLDebugLogger</a>.</p>
  /// <p><b>Note: </b>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 <a href="http://doc.qt.io/qt-5/qstring.html#length">QString::length</a>(). (It does if the message contains 7-bit ASCII only data, which is typical for debug messages.)</p></div>
  pub fn maximum_message_length(&self) -> i64 {
    unsafe {
      ::ffi::qt_gui_c_QOpenGLDebugLogger_maximumMessageLength(self as *const ::opengl_debug_logger::OpenGLDebugLogger)
    }
  }

  /// C++ method: <span style='color: green;'>```virtual const QMetaObject* QOpenGLDebugLogger::metaObject() const```</span>
  ///
  ///
  pub fn meta_object(&self) -> *const ::qt_core::meta_object::MetaObject {
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_metaObject(self as *const ::opengl_debug_logger::OpenGLDebugLogger) }
  }

  /// C++ method: <span style='color: green;'>```[constructor] void QOpenGLDebugLogger::QOpenGLDebugLogger()```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#QOpenGLDebugLogger">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new logger object with the given <i>parent</i>.</p>
  /// <p><b>Note: </b>The object must be initialized before logging can happen.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#initialize">initialize</a>().</p></div>
  pub fn new() -> ::cpp_utils::CppBox<::opengl_debug_logger::OpenGLDebugLogger> {
    let ffi_result = unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_new_no_args() };
    unsafe { ::cpp_utils::CppBox::new(ffi_result) }
  }

  /// C++ method: <span style='color: green;'>```[constructor] void QOpenGLDebugLogger::QOpenGLDebugLogger(QObject* parent = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#QOpenGLDebugLogger">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new logger object with the given <i>parent</i>.</p>
  /// <p><b>Note: </b>The object must be initialized before logging can happen.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#initialize">initialize</a>().</p></div>
  pub unsafe fn new_unsafe(parent: *mut ::qt_core::object::Object)
                           -> ::cpp_utils::CppBox<::opengl_debug_logger::OpenGLDebugLogger> {
    let ffi_result = ::ffi::qt_gui_c_QOpenGLDebugLogger_new_parent(parent);
    ::cpp_utils::CppBox::new(ffi_result)
  }

  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::popGroup()```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>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 <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Type-enum">QOpenGLDebugMessage::GroupPopType</a> and severity <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Severity-enum">QOpenGLDebugMessage::NotificationSeverity</a>.</p>
  /// <p>Popping a debug group will restore the message filtering settings of the group that becomes the top of the debug groups stack.</p>
  /// <p><b>Note: </b>The object must be initialized before managing debug groups.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">pushGroup</a>().</p></div>
  pub fn pop_group(&mut self) {
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_popGroup(self as *mut ::opengl_debug_logger::OpenGLDebugLogger) }
  }

  /// C++ method: <span style='color: green;'>```QOpenGLDebugLogger::pushGroup```</span>
  ///
  /// This is an overloaded function. Available variants:
  ///
  ///
  ///
  /// ## Variant 1
  ///
  /// Rust arguments: ```fn push_group(&mut self, &::qt_core::string::String) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::pushGroup(const QString& name)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Pushes a debug group with name <i>name</i>, id <i>id</i>, and source <i>source</i> onto the debug groups stack. If the group is successfully pushed, OpenGL will automatically log a message with message <i>name</i>, id <i>id</i>, source <i>source</i>, type <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Type-enum">QOpenGLDebugMessage::GroupPushType</a> and severity <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Severity-enum">QOpenGLDebugMessage::NotificationSeverity</a>.</p>
  /// <p>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.</p>
  /// <p><b>Note: </b>The <i>source</i> must either be <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Source-enum">QOpenGLDebugMessage::ApplicationSource</a> or <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Source-enum">QOpenGLDebugMessage::ThirdPartySource</a>, otherwise the group will not be pushed.</p><p><b>Note: </b>The object must be initialized before managing debug groups.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>().</p></div>
  ///
  /// ## Variant 2
  ///
  /// Rust arguments: ```fn push_group(&mut self, (&::qt_core::string::String, u32)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::pushGroup(const QString& name, GLuint id = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Pushes a debug group with name <i>name</i>, id <i>id</i>, and source <i>source</i> onto the debug groups stack. If the group is successfully pushed, OpenGL will automatically log a message with message <i>name</i>, id <i>id</i>, source <i>source</i>, type <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Type-enum">QOpenGLDebugMessage::GroupPushType</a> and severity <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Severity-enum">QOpenGLDebugMessage::NotificationSeverity</a>.</p>
  /// <p>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.</p>
  /// <p><b>Note: </b>The <i>source</i> must either be <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Source-enum">QOpenGLDebugMessage::ApplicationSource</a> or <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Source-enum">QOpenGLDebugMessage::ThirdPartySource</a>, otherwise the group will not be pushed.</p><p><b>Note: </b>The object must be initialized before managing debug groups.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>().</p></div>
  ///
  /// ## Variant 3
  ///
  /// Rust arguments: ```fn push_group(&mut self, (&::qt_core::string::String, u32, ::opengl_debug_message::Source)) -> ()```<br>
  /// C++ method: <span style='color: green;'>```void QOpenGLDebugLogger::pushGroup(const QString& name, GLuint id = ?, QOpenGLDebugMessage::Source source = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#pushGroup">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Pushes a debug group with name <i>name</i>, id <i>id</i>, and source <i>source</i> onto the debug groups stack. If the group is successfully pushed, OpenGL will automatically log a message with message <i>name</i>, id <i>id</i>, source <i>source</i>, type <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Type-enum">QOpenGLDebugMessage::GroupPushType</a> and severity <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Severity-enum">QOpenGLDebugMessage::NotificationSeverity</a>.</p>
  /// <p>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.</p>
  /// <p><b>Note: </b>The <i>source</i> must either be <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Source-enum">QOpenGLDebugMessage::ApplicationSource</a> or <a href="http://doc.qt.io/qt-5/qopengldebugmessage.html#Source-enum">QOpenGLDebugMessage::ThirdPartySource</a>, otherwise the group will not be pushed.</p><p><b>Note: </b>The object must be initialized before managing debug groups.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#popGroup">popGroup</a>(), <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#enableMessages">enableMessages</a>(), and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#disableMessages">disableMessages</a>().</p></div>
  pub fn push_group<'largs, Args>(&'largs mut self, args: Args) -> ()
    where Args: overloading::OpenGLDebugLoggerPushGroupArgs<'largs>
  {
    args.exec(self)
  }
  /// C++ method: <span style='color: green;'>```virtual int QOpenGLDebugLogger::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>
  ///
  ///
  pub unsafe fn qt_metacall(&mut self,
                            arg1: ::qt_core::meta_object::Call,
                            arg2: ::libc::c_int,
                            arg3: *mut *mut ::libc::c_void)
                            -> ::libc::c_int {
    ::ffi::qt_gui_c_QOpenGLDebugLogger_qt_metacall(self as *mut ::opengl_debug_logger::OpenGLDebugLogger,
                                                   arg1,
                                                   arg2,
                                                   arg3)
  }

  /// C++ method: <span style='color: green;'>```virtual void* QOpenGLDebugLogger::qt_metacast(const char* arg1)```</span>
  ///
  ///
  pub unsafe fn qt_metacast(&mut self, arg1: *const ::libc::c_char) -> *mut ::libc::c_void {
    ::ffi::qt_gui_c_QOpenGLDebugLogger_qt_metacast(self as *mut ::opengl_debug_logger::OpenGLDebugLogger, arg1)
  }

  /// C++ method: <span style='color: green;'>```QOpenGLDebugLogger::startLogging```</span>
  ///
  /// This is an overloaded function. Available variants:
  ///
  ///
  ///
  /// ## Variant 1
  ///
  /// Rust arguments: ```fn start_logging(&mut self, ()) -> ()```<br>
  /// C++ method: <span style='color: green;'>```[slot] void QOpenGLDebugLogger::startLogging()```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#startLogging">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Starts logging messages coming from the OpenGL server. When a new message is received, the signal <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#messageLogged">messageLogged</a>() is emitted, carrying the logged message as argument.</p>
  /// <p><i>loggingMode</i> specifies whether the logging must be asynchronous (the default) or synchronous.</p>
  /// <p><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html">QOpenGLDebugLogger</a> will record the values of <code>GL_DEBUG_OUTPUT</code> and <code>GL_DEBUG_OUTPUT_SYNCHRONOUS</code> 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; <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html">QOpenGLDebugLogger</a> will ensure that the pre-existing callback will still be invoked when logging.</p>
  /// <p><b>Note: </b>It's not possible to change the logging mode without stopping and starting logging again. This might change in a future version of Qt.</p><p><b>Note: </b>The object must be initialized before logging can happen.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#stopLogging">stopLogging</a>() and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#initialize">initialize</a>().</p></div>
  ///
  /// ## Variant 2
  ///
  /// Rust arguments: ```fn start_logging(&mut self, ::opengl_debug_logger::LoggingMode) -> ()```<br>
  /// C++ method: <span style='color: green;'>```[slot] void QOpenGLDebugLogger::startLogging(QOpenGLDebugLogger::LoggingMode loggingMode = ?)```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#startLogging">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Starts logging messages coming from the OpenGL server. When a new message is received, the signal <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#messageLogged">messageLogged</a>() is emitted, carrying the logged message as argument.</p>
  /// <p><i>loggingMode</i> specifies whether the logging must be asynchronous (the default) or synchronous.</p>
  /// <p><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html">QOpenGLDebugLogger</a> will record the values of <code>GL_DEBUG_OUTPUT</code> and <code>GL_DEBUG_OUTPUT_SYNCHRONOUS</code> 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; <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html">QOpenGLDebugLogger</a> will ensure that the pre-existing callback will still be invoked when logging.</p>
  /// <p><b>Note: </b>It's not possible to change the logging mode without stopping and starting logging again. This might change in a future version of Qt.</p><p><b>Note: </b>The object must be initialized before logging can happen.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#stopLogging">stopLogging</a>() and <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#initialize">initialize</a>().</p></div>
  pub fn start_logging<'largs, Args>(&'largs mut self, args: Args) -> ()
    where Args: overloading::OpenGLDebugLoggerStartLoggingArgs<'largs>
  {
    args.exec(self)
  }
  /// C++ method: <span style='color: green;'>```[slot] void QOpenGLDebugLogger::stopLogging()```</span>
  ///
  /// <a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#stopLogging">C++ documentation:</a> <div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Stops logging messages from the OpenGL server.</p>
  /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qopengldebuglogger.html#startLogging">startLogging</a>().</p></div>
  pub fn stop_logging(&mut self) {
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_stopLogging(self as *mut ::opengl_debug_logger::OpenGLDebugLogger) }
  }

  /// C++ method: <span style='color: green;'>```static QString QOpenGLDebugLogger::tr(const char* s, const char* c, int n)```</span>
  ///
  ///
  pub unsafe fn tr(s: *const ::libc::c_char, c: *const ::libc::c_char, n: ::libc::c_int) -> ::qt_core::string::String {
    {
      let mut object: ::qt_core::string::String =
        ::cpp_utils::new_uninitialized::NewUninitialized::new_uninitialized();
      ::ffi::qt_gui_c_QOpenGLDebugLogger_tr_to_output(s, c, n, &mut object);
      object
    }
  }

  /// C++ method: <span style='color: green;'>```static QString QOpenGLDebugLogger::trUtf8(const char* s, const char* c, int n)```</span>
  ///
  ///
  pub unsafe fn tr_utf8(s: *const ::libc::c_char,
                        c: *const ::libc::c_char,
                        n: ::libc::c_int)
                        -> ::qt_core::string::String {
    {
      let mut object: ::qt_core::string::String =
        ::cpp_utils::new_uninitialized::NewUninitialized::new_uninitialized();
      ::ffi::qt_gui_c_QOpenGLDebugLogger_trUtf8_to_output(s, c, n, &mut object);
      object
    }
  }
}

impl ::cpp_utils::CppDeletable for ::opengl_debug_logger::OpenGLDebugLogger {
  fn deleter() -> ::cpp_utils::Deleter<Self> {
    ::ffi::qt_gui_c_QOpenGLDebugLogger_delete
  }
}

/// Types for accessing built-in Qt signals and slots present in this module
pub mod connection {
  use ::cpp_utils::StaticCast;
  /// Provides access to built-in Qt signals of `OpenGLDebugLogger`.
  pub struct Signals<'a>(&'a ::opengl_debug_logger::OpenGLDebugLogger);
  /// Represents a built-in Qt signal `QOpenGLDebugLogger::objectNameChanged`.
  ///
  /// An object of this type can be created from `OpenGLDebugLogger` with `object.signals().object_name_changed()` and used for creating Qt connections using `qt_core::connection` API. After the connection is made, the object can (should) be dropped. The connection will remain active until sender or receiver are destroyed or until a manual disconnection is made.
  ///
  /// An object of this type contains a reference to the original `OpenGLDebugLogger` object.
  pub struct ObjectNameChanged<'a>(&'a ::opengl_debug_logger::OpenGLDebugLogger);
  impl<'a> ::qt_core::connection::Receiver for ObjectNameChanged<'a> {
    type Arguments = (&'static ::qt_core::string::String,);
    fn object(&self) -> &::qt_core::object::Object {
      self.0.static_cast()
    }
    fn receiver_id() -> &'static [u8] {
      b"2objectNameChanged(const QString&)\0"
    }
  }
  impl<'a> ::qt_core::connection::Signal for ObjectNameChanged<'a> {}
  /// Represents a built-in Qt signal `QOpenGLDebugLogger::messageLogged`.
  ///
  /// An object of this type can be created from `OpenGLDebugLogger` with `object.signals().message_logged()` and used for creating Qt connections using `qt_core::connection` API. After the connection is made, the object can (should) be dropped. The connection will remain active until sender or receiver are destroyed or until a manual disconnection is made.
  ///
  /// An object of this type contains a reference to the original `OpenGLDebugLogger` object.
  pub struct MessageLogged<'a>(&'a ::opengl_debug_logger::OpenGLDebugLogger);
  impl<'a> ::qt_core::connection::Receiver for MessageLogged<'a> {
    type Arguments = (&'static ::opengl_debug_message::OpenGLDebugMessage,);
    fn object(&self) -> &::qt_core::object::Object {
      self.0.static_cast()
    }
    fn receiver_id() -> &'static [u8] {
      b"2messageLogged(const QOpenGLDebugMessage&)\0"
    }
  }
  impl<'a> ::qt_core::connection::Signal for MessageLogged<'a> {}
  impl<'a> Signals<'a> {
    /// Returns an object representing a built-in Qt signal `QOpenGLDebugLogger::objectNameChanged`.
    ///
    /// Return value of this function can be used for creating Qt connections using `qt_core::connection` API.
    pub fn object_name_changed(&self) -> ObjectNameChanged {
      ObjectNameChanged(self.0)
    }
    /// Returns an object representing a built-in Qt signal `QOpenGLDebugLogger::messageLogged`.
    ///
    /// Return value of this function can be used for creating Qt connections using `qt_core::connection` API.
    pub fn message_logged(&self) -> MessageLogged {
      MessageLogged(self.0)
    }
  }
  /// Provides access to built-in Qt slots of `OpenGLDebugLogger`.
  pub struct Slots<'a>(&'a ::opengl_debug_logger::OpenGLDebugLogger);
  /// Represents a built-in Qt slot `QOpenGLDebugLogger::stopLogging`.
  ///
  /// An object of this type can be created from `OpenGLDebugLogger` with `object.slots().stop_logging()` and used for creating Qt connections using `qt_core::connection` API. After the connection is made, the object can (should) be dropped. The connection will remain active until sender or receiver are destroyed or until a manual disconnection is made.
  ///
  /// An object of this type contains a reference to the original `OpenGLDebugLogger` object.
  pub struct StopLogging<'a>(&'a ::opengl_debug_logger::OpenGLDebugLogger);
  impl<'a> ::qt_core::connection::Receiver for StopLogging<'a> {
    type Arguments = ();
    fn object(&self) -> &::qt_core::object::Object {
      self.0.static_cast()
    }
    fn receiver_id() -> &'static [u8] {
      b"1stopLogging()\0"
    }
  }
  /// Represents a built-in Qt slot `QOpenGLDebugLogger::logMessage`.
  ///
  /// An object of this type can be created from `OpenGLDebugLogger` with `object.slots().log_message()` and used for creating Qt connections using `qt_core::connection` API. After the connection is made, the object can (should) be dropped. The connection will remain active until sender or receiver are destroyed or until a manual disconnection is made.
  ///
  /// An object of this type contains a reference to the original `OpenGLDebugLogger` object.
  pub struct LogMessage<'a>(&'a ::opengl_debug_logger::OpenGLDebugLogger);
  impl<'a> ::qt_core::connection::Receiver for LogMessage<'a> {
    type Arguments = (&'static ::opengl_debug_message::OpenGLDebugMessage,);
    fn object(&self) -> &::qt_core::object::Object {
      self.0.static_cast()
    }
    fn receiver_id() -> &'static [u8] {
      b"1logMessage(const QOpenGLDebugMessage&)\0"
    }
  }
  /// Represents a built-in Qt slot `QOpenGLDebugLogger::startLogging`.
  ///
  /// An object of this type can be created from `OpenGLDebugLogger` with `object.slots().start_logging()` and used for creating Qt connections using `qt_core::connection` API. After the connection is made, the object can (should) be dropped. The connection will remain active until sender or receiver are destroyed or until a manual disconnection is made.
  ///
  /// An object of this type contains a reference to the original `OpenGLDebugLogger` object.
  pub struct StartLogging<'a>(&'a ::opengl_debug_logger::OpenGLDebugLogger);
  impl<'a> ::qt_core::connection::Receiver for StartLogging<'a> {
    type Arguments = (::opengl_debug_logger::LoggingMode,);
    fn object(&self) -> &::qt_core::object::Object {
      self.0.static_cast()
    }
    fn receiver_id() -> &'static [u8] {
      b"1startLogging(QOpenGLDebugLogger::LoggingMode)\0"
    }
  }
  impl<'a> Slots<'a> {
    /// Returns an object representing a built-in Qt slot `QOpenGLDebugLogger::stopLogging`.
    ///
    /// Return value of this function can be used for creating Qt connections using `qt_core::connection` API.
    pub fn stop_logging(&self) -> StopLogging {
      StopLogging(self.0)
    }
    /// Returns an object representing a built-in Qt slot `QOpenGLDebugLogger::logMessage`.
    ///
    /// Return value of this function can be used for creating Qt connections using `qt_core::connection` API.
    pub fn log_message(&self) -> LogMessage {
      LogMessage(self.0)
    }
    /// Returns an object representing a built-in Qt slot `QOpenGLDebugLogger::startLogging`.
    ///
    /// Return value of this function can be used for creating Qt connections using `qt_core::connection` API.
    pub fn start_logging(&self) -> StartLogging {
      StartLogging(self.0)
    }
  }
  impl ::opengl_debug_logger::OpenGLDebugLogger {
    /// Provides access to built-in Qt signals of this type
    pub fn signals(&self) -> Signals {
      Signals(self)
    }
    /// Provides access to built-in Qt slots of this type
    pub fn slots(&self) -> Slots {
      Slots(self)
    }
  }

}

impl ::cpp_utils::StaticCast<::qt_core::object::Object> for ::opengl_debug_logger::OpenGLDebugLogger {
  fn static_cast_mut(&mut self) -> &mut ::qt_core::object::Object {
    let ffi_result = unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_G_static_cast_QObject_ptr(self as *mut ::opengl_debug_logger::OpenGLDebugLogger) };
    unsafe { ffi_result.as_mut() }.expect("Attempted to convert null pointer to reference")
  }

  fn static_cast(&self) -> &::qt_core::object::Object {
    let ffi_result = unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_G_static_cast_QObject_ptr(self as *const ::opengl_debug_logger::OpenGLDebugLogger as *mut ::opengl_debug_logger::OpenGLDebugLogger) };
    unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
  }
}

impl ::cpp_utils::UnsafeStaticCast<::opengl_debug_logger::OpenGLDebugLogger> for ::qt_core::object::Object {
  unsafe fn static_cast_mut(&mut self) -> &mut ::opengl_debug_logger::OpenGLDebugLogger {
    let ffi_result =
      ::ffi::qt_gui_c_QOpenGLDebugLogger_G_static_cast_QOpenGLDebugLogger_ptr(self as *mut ::qt_core::object::Object);
    ffi_result.as_mut().expect("Attempted to convert null pointer to reference")
  }

  unsafe fn static_cast(&self) -> &::opengl_debug_logger::OpenGLDebugLogger {
    let ffi_result = ::ffi::qt_gui_c_QOpenGLDebugLogger_G_static_cast_QOpenGLDebugLogger_ptr(self as *const ::qt_core::object::Object as *mut ::qt_core::object::Object);
    ffi_result.as_ref().expect("Attempted to convert null pointer to reference")
  }
}

impl ::std::ops::Deref for ::opengl_debug_logger::OpenGLDebugLogger {
  type Target = ::qt_core::object::Object;
  fn deref(&self) -> &::qt_core::object::Object {
    let ffi_result = unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_G_static_cast_QObject_ptr(self as *const ::opengl_debug_logger::OpenGLDebugLogger as *mut ::opengl_debug_logger::OpenGLDebugLogger) };
    unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
  }
}

impl ::std::ops::DerefMut for ::opengl_debug_logger::OpenGLDebugLogger {
  fn deref_mut(&mut self) -> &mut ::qt_core::object::Object {
    let ffi_result = unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_G_static_cast_QObject_ptr(self as *mut ::opengl_debug_logger::OpenGLDebugLogger) };
    unsafe { ffi_result.as_mut() }.expect("Attempted to convert null pointer to reference")
  }
}

/// Types for emulating overloading for overloaded functions in this module
pub mod overloading {
  /// This trait represents a set of arguments accepted by [OpenGLDebugLogger::disable_messages](../struct.OpenGLDebugLogger.html#method.disable_messages) method.
  pub trait OpenGLDebugLoggerDisableMessagesArgs<'largs> {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> ();
  }
  impl<'largs> OpenGLDebugLoggerDisableMessagesArgs<'largs> for &'largs ::vector::VectorU32 {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
      let ids = self;
      unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_disableMessages_ids(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, ids as *const ::vector::VectorU32) }
    }
  }
  impl<'largs> OpenGLDebugLoggerDisableMessagesArgs<'largs> for (&'largs ::vector::VectorU32,::qt_core::flags::Flags<::opengl_debug_message::Source>) {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let ids = self.0;
let sources = self.1;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_disableMessages_ids_sources(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, ids as *const ::vector::VectorU32, sources.to_int() as ::libc::c_uint) }
  }
}
  impl<'largs> OpenGLDebugLoggerDisableMessagesArgs<'largs> for (&'largs ::vector::VectorU32,::qt_core::flags::Flags<::opengl_debug_message::Source>,::qt_core::flags::Flags<::opengl_debug_message::Type>) {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let ids = self.0;
let sources = self.1;
let types = self.2;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_disableMessages_ids_sources_types(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, ids as *const ::vector::VectorU32, sources.to_int() as ::libc::c_uint, types.to_int() as ::libc::c_uint) }
  }
}
  impl<'largs> OpenGLDebugLoggerDisableMessagesArgs<'largs> for () {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {

      unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_disableMessages_no_args(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger) }
    }
  }
  impl<'largs> OpenGLDebugLoggerDisableMessagesArgs<'largs> for ::qt_core::flags::Flags<::opengl_debug_message::Source> {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let sources = self;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_disableMessages_sources(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, sources.to_int() as ::libc::c_uint) }
  }
}
  impl<'largs> OpenGLDebugLoggerDisableMessagesArgs<'largs> for (::qt_core::flags::Flags<::opengl_debug_message::Source>,::qt_core::flags::Flags<::opengl_debug_message::Type>) {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let sources = self.0;
let types = self.1;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_disableMessages_sources_types(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, sources.to_int() as ::libc::c_uint, types.to_int() as ::libc::c_uint) }
  }
}
  impl<'largs> OpenGLDebugLoggerDisableMessagesArgs<'largs> for (::qt_core::flags::Flags<::opengl_debug_message::Source>,::qt_core::flags::Flags<::opengl_debug_message::Type>,::qt_core::flags::Flags<::opengl_debug_message::Severity>) {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let sources = self.0;
let types = self.1;
let severities = self.2;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_disableMessages_sources_types_severities(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, sources.to_int() as ::libc::c_uint, types.to_int() as ::libc::c_uint, severities.to_int() as ::libc::c_uint) }
  }
}
  /// This trait represents a set of arguments accepted by [OpenGLDebugLogger::enable_messages](../struct.OpenGLDebugLogger.html#method.enable_messages) method.
  pub trait OpenGLDebugLoggerEnableMessagesArgs<'largs> {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> ();
  }
  impl<'largs> OpenGLDebugLoggerEnableMessagesArgs<'largs> for &'largs ::vector::VectorU32 {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
      let ids = self;
      unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_enableMessages_ids(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, ids as *const ::vector::VectorU32) }
    }
  }
  impl<'largs> OpenGLDebugLoggerEnableMessagesArgs<'largs> for (&'largs ::vector::VectorU32,::qt_core::flags::Flags<::opengl_debug_message::Source>) {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let ids = self.0;
let sources = self.1;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_enableMessages_ids_sources(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, ids as *const ::vector::VectorU32, sources.to_int() as ::libc::c_uint) }
  }
}
  impl<'largs> OpenGLDebugLoggerEnableMessagesArgs<'largs> for (&'largs ::vector::VectorU32,::qt_core::flags::Flags<::opengl_debug_message::Source>,::qt_core::flags::Flags<::opengl_debug_message::Type>) {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let ids = self.0;
let sources = self.1;
let types = self.2;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_enableMessages_ids_sources_types(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, ids as *const ::vector::VectorU32, sources.to_int() as ::libc::c_uint, types.to_int() as ::libc::c_uint) }
  }
}
  impl<'largs> OpenGLDebugLoggerEnableMessagesArgs<'largs> for () {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {

      unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_enableMessages_no_args(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger) }
    }
  }
  impl<'largs> OpenGLDebugLoggerEnableMessagesArgs<'largs> for ::qt_core::flags::Flags<::opengl_debug_message::Source> {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let sources = self;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_enableMessages_sources(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, sources.to_int() as ::libc::c_uint) }
  }
}
  impl<'largs> OpenGLDebugLoggerEnableMessagesArgs<'largs> for (::qt_core::flags::Flags<::opengl_debug_message::Source>,::qt_core::flags::Flags<::opengl_debug_message::Type>) {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let sources = self.0;
let types = self.1;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_enableMessages_sources_types(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, sources.to_int() as ::libc::c_uint, types.to_int() as ::libc::c_uint) }
  }
}
  impl<'largs> OpenGLDebugLoggerEnableMessagesArgs<'largs> for (::qt_core::flags::Flags<::opengl_debug_message::Source>,::qt_core::flags::Flags<::opengl_debug_message::Type>,::qt_core::flags::Flags<::opengl_debug_message::Severity>) {

  fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
    let sources = self.0;
let types = self.1;
let severities = self.2;
    unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_enableMessages_sources_types_severities(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, sources.to_int() as ::libc::c_uint, types.to_int() as ::libc::c_uint, severities.to_int() as ::libc::c_uint) }
  }
}
  /// This trait represents a set of arguments accepted by [OpenGLDebugLogger::push_group](../struct.OpenGLDebugLogger.html#method.push_group) method.
  pub trait OpenGLDebugLoggerPushGroupArgs<'largs> {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> ();
  }
  impl<'largs> OpenGLDebugLoggerPushGroupArgs<'largs> for &'largs ::qt_core::string::String {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
      let name = self;
      unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_pushGroup_name(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, name as *const ::qt_core::string::String) }
    }
  }
  impl<'largs> OpenGLDebugLoggerPushGroupArgs<'largs> for (&'largs ::qt_core::string::String, u32) {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
      let name = self.0;
      let id = self.1;
      unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_pushGroup_name_id(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, name as *const ::qt_core::string::String, id) }
    }
  }
  impl<'largs> OpenGLDebugLoggerPushGroupArgs<'largs>
    for (&'largs ::qt_core::string::String, u32, ::opengl_debug_message::Source) {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
      let name = self.0;
      let id = self.1;
      let source = self.2;
      unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_pushGroup_name_id_source(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, name as *const ::qt_core::string::String, id, source) }
    }
  }
  /// This trait represents a set of arguments accepted by [OpenGLDebugLogger::start_logging](../struct.OpenGLDebugLogger.html#method.start_logging) method.
  pub trait OpenGLDebugLoggerStartLoggingArgs<'largs> {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> ();
  }
  impl<'largs> OpenGLDebugLoggerStartLoggingArgs<'largs> for ::opengl_debug_logger::LoggingMode {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {
      let logging_mode = self;
      unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_startLogging_loggingMode(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger, logging_mode) }
    }
  }
  impl<'largs> OpenGLDebugLoggerStartLoggingArgs<'largs> for () {
    fn exec(self, original_self: &'largs mut ::opengl_debug_logger::OpenGLDebugLogger) -> () {

      unsafe { ::ffi::qt_gui_c_QOpenGLDebugLogger_startLogging_no_args(original_self as *mut ::opengl_debug_logger::OpenGLDebugLogger) }
    }
  }
}