ruby-qt6-qtcore 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7986e32744ab5746e42c264d85013dc7a839fb49c4e90d491ebfee1874f00293
-  data.tar.gz: dac74a4ef3a27495c418075ec7731e50c1d0c289b9b7623baa946b9a3e3ac963
+  metadata.gz: 293e494bd4d1c313d860e06950b8dfa8f3c3ed9a58e217cfaa4c298b4115bca5
+  data.tar.gz: a180f07e7a2d747cdec91f05a8fb7cd93ae9278350eefe136cf7493fba573b09
 SHA512:
-  metadata.gz: 58af64dfd6a6b70661bb75af287ed037c5ce4b100c02986d00de7657ee2c97192f2d5a1829d0c1bf66406d34afcae5da7f72e50d3d2d3963784d1e0b5048a65f
-  data.tar.gz: 5b97b6a54317f556c5e15fedf6ea4b618b7b5a32de68dc069f5c3a9621d92eb344f21c31de37e36532445100eed4e832e61766b29bc8ddf775d91e0411c4d276
+  metadata.gz: 5502974f45eda419800fda383eab988c7edbcfc162b6fda2e6e088ff40f3ca2052eb921451ea97850ef3e3e8f735e08fcdb808de95bf8440daefeef78fa842ee
+  data.tar.gz: aebf08d7f6b0daa102c258779886df73b1def1212db5e2dc4d8ca4886be9e302a9f231302dee408f2866fced10111a9116a0e5b3d9d8dee6209dab876801834a

data/ext/qt6/qtcore/qeventloop-rb.cpp

@@ -0,0 +1,33 @@
+#include "qeventloop-rb.hpp"
+#include <qeventloop.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQEventLoop;
+
+void Init_qeventloop(Module rb_mQt6QtCore)
+{
+    rb_cQEventLoop =
+        // RubyQt6::QtCore::QEventLoop
+        define_class_under<QEventLoop, QObject>(rb_mQt6QtCore, "QEventLoop")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QEventLoop::staticMetaObject; });
+
+    Data_Type<QEventLoop::ProcessEventsFlag> rb_cQEventLoopProcessEventsFlag =
+        // RubyQt6::QtCore::QEventLoop::ProcessEventsFlag
+        define_qenum_under<QEventLoop::ProcessEventsFlag>(rb_cQEventLoop, "ProcessEventsFlag");
+        define_qenum_value_under(rb_cQEventLoopProcessEventsFlag, "AllEvents", QEventLoop::ProcessEventsFlag::AllEvents);
+        define_qenum_value_under(rb_cQEventLoopProcessEventsFlag, "ExcludeUserInputEvents", QEventLoop::ProcessEventsFlag::ExcludeUserInputEvents);
+        define_qenum_value_under(rb_cQEventLoopProcessEventsFlag, "ExcludeSocketNotifiers", QEventLoop::ProcessEventsFlag::ExcludeSocketNotifiers);
+        define_qenum_value_under(rb_cQEventLoopProcessEventsFlag, "WaitForMoreEvents", QEventLoop::ProcessEventsFlag::WaitForMoreEvents);
+        define_qenum_value_under(rb_cQEventLoopProcessEventsFlag, "X11ExcludeTimers", QEventLoop::ProcessEventsFlag::X11ExcludeTimers);
+        define_qenum_value_under(rb_cQEventLoopProcessEventsFlag, "EventLoopExec", QEventLoop::ProcessEventsFlag::EventLoopExec);
+        define_qenum_value_under(rb_cQEventLoopProcessEventsFlag, "DialogExec", QEventLoop::ProcessEventsFlag::DialogExec);
+        define_qenum_value_under(rb_cQEventLoopProcessEventsFlag, "ApplicationExec", QEventLoop::ProcessEventsFlag::ApplicationExec);
+
+    Data_Type<QFlags<QEventLoop::ProcessEventsFlag>> rb_cQEventLoopProcessEventsFlags =
+        // RubyQt6::QtCore::QEventLoop::ProcessEventsFlags
+        define_qflags_under<QEventLoop::ProcessEventsFlag>(rb_cQEventLoop, "ProcessEventsFlags");
+}

data/ext/qt6/qtcore/qeventloop-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qeventloop(Module rb_mQt6QtCore);

data/ext/qt6/qtcore/qlocale-rb.cpp

@@ -40,7 +40,6 @@ void Init_qlocale(Module rb_mQt6QtCore)
             .define_method("percent", &QLocale::percent)
             .define_method("pm_text", &QLocale::pmText)
             .define_method("positive_sign", &QLocale::positiveSign)
-            .define_method<QString (QLocale::*)(QStringView, QLocale::QuotationStyle) const>("quote_string", &QLocale::quoteString, Arg("str"), Arg("style") = static_cast<QLocale::QuotationStyle>(QLocale::QuotationStyle::StandardQuotation))
             .define_method<QString (QLocale::*)(const QString &, QLocale::QuotationStyle) const>("quote_string", &QLocale::quoteString, Arg("str"), Arg("style") = static_cast<QLocale::QuotationStyle>(QLocale::QuotationStyle::StandardQuotation))
             .define_method("script", &QLocale::script)
             .define_method("set_number_options", &QLocale::setNumberOptions, Arg("options"))
@@ -65,34 +64,23 @@ void Init_qlocale(Module rb_mQt6QtCore)
             .define_method<QDateTime (QLocale::*)(const QString &, QLocale::FormatType, int) const>("to_date_time", &QLocale::toDateTime, Arg("string"), Arg("format") = static_cast<QLocale::FormatType>(QLocale::FormatType::LongFormat), Arg("base_year") = static_cast<int>(QLocale::DefaultTwoDigitBaseYear))
             .define_method<QDateTime (QLocale::*)(const QString &, const QString &, QCalendar, int) const>("to_date_time", &QLocale::toDateTime, Arg("string"), Arg("format"), Arg("cal"), Arg("base_year") = static_cast<int>(QLocale::DefaultTwoDigitBaseYear))
             .define_method<QDateTime (QLocale::*)(const QString &, const QString &, int) const>("to_date_time", &QLocale::toDateTime, Arg("string"), Arg("format"), Arg("base_year") = static_cast<int>(QLocale::DefaultTwoDigitBaseYear))
-            .define_method<double (QLocale::*)(QStringView, bool *) const>("to_double", &QLocale::toDouble, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<double (QLocale::*)(const QString &, bool *) const>("to_double", &QLocale::toDouble, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
-            .define_method<float (QLocale::*)(QStringView, bool *) const>("to_float", &QLocale::toFloat, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<float (QLocale::*)(const QString &, bool *) const>("to_float", &QLocale::toFloat, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
-            .define_method<int (QLocale::*)(QStringView, bool *) const>("to_int", &QLocale::toInt, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<int (QLocale::*)(const QString &, bool *) const>("to_int", &QLocale::toInt, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
-            .define_method<long (QLocale::*)(QStringView, bool *) const>("to_long", &QLocale::toLong, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<long (QLocale::*)(const QString &, bool *) const>("to_long", &QLocale::toLong, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
-            .define_method<qlonglong (QLocale::*)(QStringView, bool *) const>("to_longlong", &QLocale::toLongLong, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<qlonglong (QLocale::*)(const QString &, bool *) const>("to_longlong", &QLocale::toLongLong, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method("to_lower", &QLocale::toLower, Arg("str"))
-            .define_method<short (QLocale::*)(QStringView, bool *) const>("to_short", &QLocale::toShort, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<short (QLocale::*)(const QString &, bool *) const>("to_short", &QLocale::toShort, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<QString (QLocale::*)(uint) const>("to_string", &QLocale::toString, Arg("i"))
             .define_method<QString (QLocale::*)(ulong) const>("to_string", &QLocale::toString, Arg("i"))
             .define_method<QString (QLocale::*)(ushort) const>("to_string", &QLocale::toString, Arg("i"))
             .define_method<QString (QLocale::*)(QDate, QLocale::FormatType) const>("to_string", &QLocale::toString, Arg("date"), Arg("format") = static_cast<QLocale::FormatType>(QLocale::FormatType::LongFormat))
             .define_method<QString (QLocale::*)(QDate, QLocale::FormatType, QCalendar) const>("to_string", &QLocale::toString, Arg("date"), Arg("format"), Arg("cal"))
-            .define_method<QString (QLocale::*)(QDate, QStringView) const>("to_string", &QLocale::toString, Arg("date"), Arg("format"))
-            .define_method<QString (QLocale::*)(QDate, QStringView, QCalendar) const>("to_string", &QLocale::toString, Arg("date"), Arg("format"), Arg("cal"))
             .define_method<QString (QLocale::*)(QDate, const QString &) const>("to_string", &QLocale::toString, Arg("date"), Arg("format"))
             .define_method<QString (QLocale::*)(QTime, QLocale::FormatType) const>("to_string", &QLocale::toString, Arg("time"), Arg("format") = static_cast<QLocale::FormatType>(QLocale::FormatType::LongFormat))
-            .define_method<QString (QLocale::*)(QTime, QStringView) const>("to_string", &QLocale::toString, Arg("time"), Arg("format"))
             .define_method<QString (QLocale::*)(QTime, const QString &) const>("to_string", &QLocale::toString, Arg("time"), Arg("format"))
             .define_method<QString (QLocale::*)(const QDateTime &, QLocale::FormatType) const>("to_string", &QLocale::toString, Arg("date_time"), Arg("format") = static_cast<QLocale::FormatType>(QLocale::FormatType::LongFormat))
             .define_method<QString (QLocale::*)(const QDateTime &, QLocale::FormatType, QCalendar) const>("to_string", &QLocale::toString, Arg("date_time"), Arg("format"), Arg("cal"))
-            .define_method<QString (QLocale::*)(const QDateTime &, QStringView) const>("to_string", &QLocale::toString, Arg("date_time"), Arg("format"))
-            .define_method<QString (QLocale::*)(const QDateTime &, QStringView, QCalendar) const>("to_string", &QLocale::toString, Arg("date_time"), Arg("format"), Arg("cal"))
             .define_method<QString (QLocale::*)(const QDateTime &, const QString &) const>("to_string", &QLocale::toString, Arg("date_time"), Arg("format"))
             .define_method<QString (QLocale::*)(double, char, int) const>("to_string", &QLocale::toString, Arg("f"), Arg("format") = static_cast<char>('g'), Arg("precision") = static_cast<int>(6))
             .define_method<QString (QLocale::*)(float, char, int) const>("to_string", &QLocale::toString, Arg("f"), Arg("format") = static_cast<char>('g'), Arg("precision") = static_cast<int>(6))
@@ -103,13 +91,9 @@ void Init_qlocale(Module rb_mQt6QtCore)
             .define_method<QString (QLocale::*)(short) const>("to_string", &QLocale::toString, Arg("i"))
             .define_method<QTime (QLocale::*)(const QString &, QLocale::FormatType) const>("to_time", &QLocale::toTime, Arg("string"), Arg("format") = static_cast<QLocale::FormatType>(QLocale::FormatType::LongFormat))
             .define_method<QTime (QLocale::*)(const QString &, const QString &) const>("to_time", &QLocale::toTime, Arg("string"), Arg("format"))
-            .define_method<uint (QLocale::*)(QStringView, bool *) const>("to_uint", &QLocale::toUInt, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<uint (QLocale::*)(const QString &, bool *) const>("to_uint", &QLocale::toUInt, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
-            .define_method<ulong (QLocale::*)(QStringView, bool *) const>("to_ulong", &QLocale::toULong, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<ulong (QLocale::*)(const QString &, bool *) const>("to_ulong", &QLocale::toULong, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
-            .define_method<qulonglong (QLocale::*)(QStringView, bool *) const>("to_ulonglong", &QLocale::toULongLong, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<qulonglong (QLocale::*)(const QString &, bool *) const>("to_ulonglong", &QLocale::toULongLong, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
-            .define_method<ushort (QLocale::*)(QStringView, bool *) const>("to_ushort", &QLocale::toUShort, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method<ushort (QLocale::*)(const QString &, bool *) const>("to_ushort", &QLocale::toUShort, Arg("s"), Arg("ok") = static_cast<bool *>(nullptr))
             .define_method("to_upper", &QLocale::toUpper, Arg("str"))
             .define_method("ui_languages", &QLocale::uiLanguages, Arg("separator") = static_cast<QLocale::TagSeparator>(QLocale::TagSeparator::Dash))

data/ext/qt6/qtcore/qobject-rb.cpp

@@ -31,6 +31,7 @@ void Init_qobject(Module rb_mQt6QtCore)
         // RubyQt6::QtCore::QObject
         define_class_under<QObject>(rb_mQt6QtCore, "QObject")
             // RubyQt6-Defined Functions
+            .define_method("_qobject_ptr", [](QObject *self) -> uintptr_t { return (uintptr_t)self; })
             .define_singleton_function("_emit", QObject_emit, Arg("sender"), Arg("signal"), Arg("args"))
             .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QObject::staticMetaObject; })
             .define_singleton_function("_delete_now", [](QObject *object) -> void { delete object; }, Arg("object").takeOwnership())

data/ext/qt6/qtcore/qprocess-rb.cpp

@@ -0,0 +1,123 @@
+#include "qprocess-rb.hpp"
+#include <qprocess.h>
+#include <rice/qt6/qenum.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQProcess;
+
+void Init_qprocess(Module rb_mQt6QtCore)
+{
+    rb_cQProcess =
+        // RubyQt6::QtCore::QProcess
+        define_class_under<QProcess, QIODevice>(rb_mQt6QtCore, "QProcess")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QProcess::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QProcess, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("arguments", &QProcess::arguments)
+            .define_method("bytes_to_write", &QProcess::bytesToWrite)
+            .define_method("child_process_modifier", &QProcess::childProcessModifier)
+            .define_method("close", &QProcess::close)
+            .define_method("close_read_channel", &QProcess::closeReadChannel, Arg("channel"))
+            .define_method("close_write_channel", &QProcess::closeWriteChannel)
+            .define_method("environment", &QProcess::environment)
+            .define_method("error", &QProcess::error)
+            .define_method("exit_code", &QProcess::exitCode)
+            .define_method("exit_status", &QProcess::exitStatus)
+            .define_method("fail_child_process_modifier", &QProcess::failChildProcessModifier, Arg("description"), Arg("error") = static_cast<int>(0))
+            .define_method("input_channel_mode", &QProcess::inputChannelMode)
+            .define_method("sequential?", &QProcess::isSequential)
+            .define_method("open", &QProcess::open, Arg("mode") = static_cast<QIODeviceBase::OpenMode>(QIODeviceBase::ReadWrite))
+            .define_method("process_channel_mode", &QProcess::processChannelMode)
+            .define_method("process_environment", &QProcess::processEnvironment)
+            .define_method("process_id", &QProcess::processId)
+            .define_method("program", &QProcess::program)
+            .define_method("read_all_standard_error", &QProcess::readAllStandardError)
+            .define_method("read_all_standard_output", &QProcess::readAllStandardOutput)
+            .define_method("read_channel", &QProcess::readChannel)
+            .define_method("set_arguments", &QProcess::setArguments, Arg("arguments"))
+            .define_method("set_child_process_modifier", &QProcess::setChildProcessModifier, Arg("modifier"))
+            .define_method("set_environment", &QProcess::setEnvironment, Arg("environment"))
+            .define_method("set_input_channel_mode", &QProcess::setInputChannelMode, Arg("mode"))
+            .define_method("set_process_channel_mode", &QProcess::setProcessChannelMode, Arg("mode"))
+            .define_method("set_process_environment", &QProcess::setProcessEnvironment, Arg("environment"))
+            .define_method("set_program", &QProcess::setProgram, Arg("program"))
+            .define_method("set_read_channel", &QProcess::setReadChannel, Arg("channel"))
+            .define_method("set_standard_error_file", &QProcess::setStandardErrorFile, Arg("file_name"), Arg("mode") = static_cast<QIODeviceBase::OpenMode>(QIODeviceBase::Truncate))
+            .define_method("set_standard_input_file", &QProcess::setStandardInputFile, Arg("file_name"))
+            .define_method("set_standard_output_file", &QProcess::setStandardOutputFile, Arg("file_name"), Arg("mode") = static_cast<QIODeviceBase::OpenMode>(QIODeviceBase::Truncate))
+            .define_method("set_standard_output_process", &QProcess::setStandardOutputProcess, Arg("destination"))
+            .define_method("set_working_directory", &QProcess::setWorkingDirectory, Arg("dir"))
+            .define_method<void (QProcess::*)(QIODeviceBase::OpenMode)>("start", &QProcess::start, Arg("mode") = static_cast<QIODeviceBase::OpenMode>(QIODeviceBase::ReadWrite))
+            .define_method<void (QProcess::*)(const QString &, const QStringList &, QIODeviceBase::OpenMode)>("start", &QProcess::start, Arg("program"), Arg("arguments") = static_cast<const QStringList &>(QStringList {}), Arg("mode") = static_cast<QIODeviceBase::OpenMode>(QIODeviceBase::ReadWrite))
+            .define_method("start_command", &QProcess::startCommand, Arg("command"), Arg("mode") = static_cast<QIODeviceBase::OpenMode>(QIODeviceBase::ReadWrite))
+            .define_method<bool (QProcess::*)(qint64 *)>("start_detached", &QProcess::startDetached, Arg("pid") = static_cast<qint64 *>(nullptr))
+            .define_method("state", &QProcess::state)
+            .define_method("wait_for_bytes_written", &QProcess::waitForBytesWritten, Arg("msecs") = static_cast<int>(30000))
+            .define_method("wait_for_finished", &QProcess::waitForFinished, Arg("msecs") = static_cast<int>(30000))
+            .define_method("wait_for_ready_read", &QProcess::waitForReadyRead, Arg("msecs") = static_cast<int>(30000))
+            .define_method("wait_for_started", &QProcess::waitForStarted, Arg("msecs") = static_cast<int>(30000))
+            .define_method("working_directory", &QProcess::workingDirectory)
+            // Public Slots
+            .define_method("kill", &QProcess::kill)
+            .define_method("terminate", &QProcess::terminate)
+            // Signals
+            // .define_method("error_occurred", &QProcess::errorOccurred, Arg("error"))
+            // .define_method("finished", &QProcess::finished, Arg("exit_code"), Arg("exit_status") = static_cast<QProcess::ExitStatus>(QProcess::NormalExit))
+            // .define_method("ready_read_standard_error", &QProcess::readyReadStandardError)
+            // .define_method("ready_read_standard_output", &QProcess::readyReadStandardOutput)
+            // .define_method("started", &QProcess::started)
+            // .define_method("state_changed", &QProcess::stateChanged, Arg("state"))
+            // Static Public Members
+            .define_singleton_function("_execute", &QProcess::execute, Arg("program"), Arg("arguments"))
+            .define_singleton_function("null_device", &QProcess::nullDevice)
+            .define_singleton_function("split_command", &QProcess::splitCommand, Arg("command"))
+            .define_singleton_function<bool (*)(const QString &, const QStringList &, const QString &, qint64 *)>("start_detached", &QProcess::startDetached, Arg("program"), Arg("arguments") = static_cast<const QStringList &>(QStringList {}), Arg("working_directory") = static_cast<const QString &>(QString()), Arg("pid") = static_cast<qint64 *>(nullptr))
+            .define_singleton_function("system_environment", &QProcess::systemEnvironment);
+
+    Data_Type<QProcess::ExitStatus> rb_cQProcessExitStatus =
+        // RubyQt6::QtCore::QProcess::ExitStatus
+        define_qenum_under<QProcess::ExitStatus>(rb_cQProcess, "ExitStatus");
+        define_qenum_value_under(rb_cQProcessExitStatus, "NormalExit", QProcess::ExitStatus::NormalExit);
+        define_qenum_value_under(rb_cQProcessExitStatus, "CrashExit", QProcess::ExitStatus::CrashExit);
+
+    Data_Type<QProcess::InputChannelMode> rb_cQProcessInputChannelMode =
+        // RubyQt6::QtCore::QProcess::InputChannelMode
+        define_qenum_under<QProcess::InputChannelMode>(rb_cQProcess, "InputChannelMode");
+        define_qenum_value_under(rb_cQProcessInputChannelMode, "ManagedInputChannel", QProcess::InputChannelMode::ManagedInputChannel);
+        define_qenum_value_under(rb_cQProcessInputChannelMode, "ForwardedInputChannel", QProcess::InputChannelMode::ForwardedInputChannel);
+
+    Data_Type<QProcess::ProcessChannel> rb_cQProcessProcessChannel =
+        // RubyQt6::QtCore::QProcess::ProcessChannel
+        define_qenum_under<QProcess::ProcessChannel>(rb_cQProcess, "ProcessChannel");
+        define_qenum_value_under(rb_cQProcessProcessChannel, "StandardOutput", QProcess::ProcessChannel::StandardOutput);
+        define_qenum_value_under(rb_cQProcessProcessChannel, "StandardError", QProcess::ProcessChannel::StandardError);
+
+    Data_Type<QProcess::ProcessChannelMode> rb_cQProcessProcessChannelMode =
+        // RubyQt6::QtCore::QProcess::ProcessChannelMode
+        define_qenum_under<QProcess::ProcessChannelMode>(rb_cQProcess, "ProcessChannelMode");
+        define_qenum_value_under(rb_cQProcessProcessChannelMode, "SeparateChannels", QProcess::ProcessChannelMode::SeparateChannels);
+        define_qenum_value_under(rb_cQProcessProcessChannelMode, "MergedChannels", QProcess::ProcessChannelMode::MergedChannels);
+        define_qenum_value_under(rb_cQProcessProcessChannelMode, "ForwardedChannels", QProcess::ProcessChannelMode::ForwardedChannels);
+        define_qenum_value_under(rb_cQProcessProcessChannelMode, "ForwardedOutputChannel", QProcess::ProcessChannelMode::ForwardedOutputChannel);
+        define_qenum_value_under(rb_cQProcessProcessChannelMode, "ForwardedErrorChannel", QProcess::ProcessChannelMode::ForwardedErrorChannel);
+
+    Data_Type<QProcess::ProcessError> rb_cQProcessProcessError =
+        // RubyQt6::QtCore::QProcess::ProcessError
+        define_qenum_under<QProcess::ProcessError>(rb_cQProcess, "ProcessError");
+        define_qenum_value_under(rb_cQProcessProcessError, "FailedToStart", QProcess::ProcessError::FailedToStart);
+        define_qenum_value_under(rb_cQProcessProcessError, "Crashed", QProcess::ProcessError::Crashed);
+        define_qenum_value_under(rb_cQProcessProcessError, "Timedout", QProcess::ProcessError::Timedout);
+        define_qenum_value_under(rb_cQProcessProcessError, "ReadError", QProcess::ProcessError::ReadError);
+        define_qenum_value_under(rb_cQProcessProcessError, "WriteError", QProcess::ProcessError::WriteError);
+        define_qenum_value_under(rb_cQProcessProcessError, "UnknownError", QProcess::ProcessError::UnknownError);
+
+    Data_Type<QProcess::ProcessState> rb_cQProcessProcessState =
+        // RubyQt6::QtCore::QProcess::ProcessState
+        define_qenum_under<QProcess::ProcessState>(rb_cQProcess, "ProcessState");
+        define_qenum_value_under(rb_cQProcessProcessState, "NotRunning", QProcess::ProcessState::NotRunning);
+        define_qenum_value_under(rb_cQProcessProcessState, "Starting", QProcess::ProcessState::Starting);
+        define_qenum_value_under(rb_cQProcessProcessState, "Running", QProcess::ProcessState::Running);
+}

data/ext/qt6/qtcore/qprocess-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qprocess(Module rb_mQt6QtCore);

data/ext/qt6/qtcore/qprocessenvironment-rb.cpp

@@ -0,0 +1,32 @@
+#include "qprocess-rb.hpp"
+#include <qprocess.h>
+#include <rice/qt6/qenum.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQProcessEnvironment;
+
+void Init_qprocessenvironment(Module rb_mQt6QtCore)
+{
+    rb_cQProcessEnvironment =
+        // RubyQt6::QtCore::QProcessEnvironment
+        define_class_under<QProcessEnvironment>(rb_mQt6QtCore, "QProcessEnvironment")
+            // Public Functions
+            .define_method("clear", &QProcessEnvironment::clear)
+            .define_method("contains", &QProcessEnvironment::contains, Arg("name"))
+            .define_method("inherits_from_parent", &QProcessEnvironment::inheritsFromParent)
+            .define_method<void (QProcessEnvironment::*)(const QString &, const QString &)>("insert", &QProcessEnvironment::insert, Arg("name"), Arg("value"))
+            .define_method<void (QProcessEnvironment::*)(const QProcessEnvironment &)>("insert", &QProcessEnvironment::insert, Arg("e"))
+            .define_method("empty?", &QProcessEnvironment::isEmpty)
+            .define_method("keys", &QProcessEnvironment::keys)
+            .define_method("remove", &QProcessEnvironment::remove, Arg("name"))
+            .define_method("to_string_list", &QProcessEnvironment::toStringList)
+            .define_method("value", &QProcessEnvironment::value, Arg("name"), Arg("default_value") = static_cast<const QString &>(QString()))
+            // Static Public Members
+            .define_singleton_function("system_environment", &QProcessEnvironment::systemEnvironment);
+
+    Data_Type<QProcessEnvironment::Initialization> rb_cQProcessEnvironmentInitialization =
+        // RubyQt6::QtCore::QProcessEnvironment::Initialization
+        define_qenum_under<QProcessEnvironment::Initialization>(rb_cQProcessEnvironment, "Initialization");
+        define_qenum_value_under(rb_cQProcessEnvironmentInitialization, "InheritFromParent", QProcessEnvironment::Initialization::InheritFromParent);
+}

data/ext/qt6/qtcore/qprocessenvironment-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qprocessenvironment(Module rb_mQt6QtCore);

data/ext/qt6/qtcore/qregularexpression-rb.cpp

@@ -32,13 +32,9 @@ void Init_qregularexpression(Module rb_mQt6QtCore)
             .define_method("set_pattern", &QRegularExpression::setPattern, Arg("pattern"))
             .define_method("set_pattern_options", &QRegularExpression::setPatternOptions, Arg("options"))
             // Static Public Members
-            .define_singleton_function<QString (*)(QStringView)>("anchored_pattern", &QRegularExpression::anchoredPattern, Arg("expression"))
             .define_singleton_function<QString (*)(const QString &)>("anchored_pattern", &QRegularExpression::anchoredPattern, Arg("expression"))
-            .define_singleton_function<QString (*)(QStringView)>("escape", &QRegularExpression::escape, Arg("str"))
             .define_singleton_function<QString (*)(const QString &)>("escape", &QRegularExpression::escape, Arg("str"))
-            .define_singleton_function("from_wildcard", &QRegularExpression::fromWildcard, Arg("pattern"), Arg("cs") = static_cast<Qt::CaseSensitivity>(Qt::CaseInsensitive), Arg("options") = static_cast<QRegularExpression::WildcardConversionOptions>(QRegularExpression::WildcardConversionOption::DefaultWildcardConversion))
-            .define_singleton_function<QString (*)(QStringView, QRegularExpression::WildcardConversionOptions)>("wildcard_to_regular_expression", &QRegularExpression::wildcardToRegularExpression, Arg("str"), Arg("options") = static_cast<QRegularExpression::WildcardConversionOptions>(QRegularExpression::WildcardConversionOption::DefaultWildcardConversion))
-            .define_singleton_function<QString (*)(const QString &, QRegularExpression::WildcardConversionOptions)>("wildcard_to_regular_expression", &QRegularExpression::wildcardToRegularExpression, Arg("str"), Arg("options") = static_cast<QRegularExpression::WildcardConversionOptions>(QRegularExpression::WildcardConversionOption::DefaultWildcardConversion));
+            .define_singleton_function<QString (*)(const QString &, QRegularExpression::WildcardConversionOptions)>("_wildcard_to_regular_expression", &QRegularExpression::wildcardToRegularExpression, Arg("str"), Arg("options") = static_cast<QRegularExpression::WildcardConversionOptions>(QRegularExpression::WildcardConversionOption::DefaultWildcardConversion));
 
     Data_Type<QRegularExpression::PatternOption> rb_cQRegularExpressionPatternOption =
         // RubyQt6::QtCore::QRegularExpression::PatternOption
@@ -101,8 +97,6 @@ void Init_qregularexpression(Module rb_mQt6QtCore)
             .define_method<qsizetype (QRegularExpressionMatch::*)(QAnyStringView) const>("captured_start", &QRegularExpressionMatch::capturedStart, Arg("name"))
             .define_method<qsizetype (QRegularExpressionMatch::*)(int) const>("captured_start", &QRegularExpressionMatch::capturedStart, Arg("nth") = static_cast<int>(0))
             .define_method("captured_texts", &QRegularExpressionMatch::capturedTexts)
-            .define_method<QStringView (QRegularExpressionMatch::*)(QAnyStringView) const>("captured_view", &QRegularExpressionMatch::capturedView, Arg("name"))
-            .define_method<QStringView (QRegularExpressionMatch::*)(int) const>("captured_view", &QRegularExpressionMatch::capturedView, Arg("nth") = static_cast<int>(0))
             .define_method<bool (QRegularExpressionMatch::*)(QAnyStringView) const>("has_captured", &QRegularExpressionMatch::hasCaptured, Arg("name"))
             .define_method<bool (QRegularExpressionMatch::*)(int) const>("has_captured", &QRegularExpressionMatch::hasCaptured, Arg("nth"))
             .define_method("has_match", &QRegularExpressionMatch::hasMatch)

data/ext/qt6/qtcore/qtcore-rb.cpp

@@ -31,6 +31,7 @@
 #include "qmimetype-rb.hpp"
 #include "qmodelindex-rb.hpp"
 #include "qpoint-rb.hpp"
+#include "qprocessenvironment-rb.hpp"
 #include "qrect-rb.hpp"
 #include "qregularexpression-rb.hpp"
 #include "qresource-rb.hpp"
@@ -38,15 +39,18 @@
 #include "qstandardpaths-rb.hpp"
 #include "qtextstream-rb.hpp"
 #include "qurl-rb.hpp"
+#include "qurlquery-rb.hpp"
 #include "quuid-rb.hpp"
 #include "qvariant-rb.hpp"
 
 #include "qobject-rb.hpp"
 #include "qabstractitemmodel-rb.hpp"
 #include "qcoreapplication-rb.hpp"
+#include "qeventloop-rb.hpp"
 #include "qiodevice-rb.hpp"
 #include "qfiledevice-rb.hpp"
 #include "qfile-rb.hpp"
+#include "qprocess-rb.hpp"
 #include "qitemselectionmodel-rb.hpp"
 #include "qsettings-rb.hpp"
 #include "qsignalmapper-rb.hpp"
@@ -104,6 +108,7 @@ extern "C" void Init_qtcore()
         Init_qmimetype(rb_mQt6QtCore);
         Init_qmodelindex(rb_mQt6QtCore);
         Init_qpoint(rb_mQt6QtCore);
+        Init_qprocessenvironment(rb_mQt6QtCore);
         Init_qrect(rb_mQt6QtCore);
         Init_qregularexpression(rb_mQt6QtCore);
         Init_qresource(rb_mQt6QtCore);
@@ -111,15 +116,18 @@ extern "C" void Init_qtcore()
         Init_qstandardpaths(rb_mQt6QtCore);
         Init_qtextstream(rb_mQt6QtCore);
         Init_qurl(rb_mQt6QtCore);
+        Init_qurlquery(rb_mQt6QtCore);
         Init_quuid(rb_mQt6QtCore);
         Init_qvariant(rb_mQt6QtCore);
 
         Init_qobject(rb_mQt6QtCore);
         Init_qabstractitemmodel(rb_mQt6QtCore);
         Init_qcoreapplication(rb_mQt6QtCore);
+        Init_qeventloop(rb_mQt6QtCore);
         Init_qiodevice(rb_mQt6QtCore);
         Init_qfiledevice(rb_mQt6QtCore);
         Init_qfile(rb_mQt6QtCore);
+        Init_qprocess(rb_mQt6QtCore);
         Init_qitemselectionmodel(rb_mQt6QtCore);
         Init_qsettings(rb_mQt6QtCore);
         Init_qsignalmapper(rb_mQt6QtCore);

data/ext/qt6/qtcore/qtimer-rb.cpp

@@ -29,10 +29,8 @@ void Init_qtimer(Module rb_mQt6QtCore)
             .define_method("remaining_time", &QTimer::remainingTime)
             .define_method("remaining_time_as_duration", &QTimer::remainingTimeAsDuration)
             .define_method<void (QTimer::*)(int)>("set_interval", &QTimer::setInterval, Arg("msec"))
-            .define_method<void (QTimer::*)(std::chrono::milliseconds)>("set_interval", &QTimer::setInterval, Arg("value"))
             .define_method("set_single_shot", &QTimer::setSingleShot, Arg("single_shot"))
             .define_method("set_timer_type", &QTimer::setTimerType, Arg("atype"))
-            .define_method<void (QTimer::*)(std::chrono::milliseconds)>("start", &QTimer::start, Arg("value"))
             .define_method("timer_id", &QTimer::timerId)
             .define_method("timer_type", &QTimer::timerType)
             // Public Slots

data/ext/qt6/qtcore/qurlquery-rb.cpp

@@ -0,0 +1,33 @@
+#include "qurlquery-rb.hpp"
+#include <qurlquery.h>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQUrlQuery;
+
+void Init_qurlquery(Module rb_mQt6QtCore)
+{
+    rb_cQUrlQuery =
+        // RubyQt6::QtCore::QUrlQuery
+        define_class_under<QUrlQuery>(rb_mQt6QtCore, "QUrlQuery")
+            // Constructor
+            .define_constructor(Constructor<QUrlQuery>())
+            // Public Functions
+            .define_method("_add_query_item", &QUrlQuery::addQueryItem, Arg("key"), Arg("value"))
+            .define_method("all_query_item_values", &QUrlQuery::allQueryItemValues, Arg("key"), Arg("encoding") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::PrettyDecoded))
+            .define_method("clear", &QUrlQuery::clear)
+            .define_method("_has_query_item", &QUrlQuery::hasQueryItem, Arg("key"))
+            .define_method("detached?", &QUrlQuery::isDetached)
+            .define_method("empty?", &QUrlQuery::isEmpty)
+            .define_method("query", &QUrlQuery::query, Arg("encoding") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::PrettyDecoded))
+            .define_method("query_item_value", &QUrlQuery::queryItemValue, Arg("key"), Arg("encoding") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::PrettyDecoded))
+            .define_method("query_items", &QUrlQuery::queryItems, Arg("encoding") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::PrettyDecoded))
+            .define_method("query_pair_delimiter", &QUrlQuery::queryPairDelimiter)
+            .define_method("query_value_delimiter", &QUrlQuery::queryValueDelimiter)
+            .define_method("_remove_all_query_items", &QUrlQuery::removeAllQueryItems, Arg("key"))
+            .define_method("_remove_query_item", &QUrlQuery::removeQueryItem, Arg("key"))
+            .define_method("_set_query", &QUrlQuery::setQuery, Arg("query"))
+            .define_method("set_query_delimiters", &QUrlQuery::setQueryDelimiters, Arg("value_delimiter"), Arg("pair_delimiter"))
+            .define_method("set_query_items", &QUrlQuery::setQueryItems, Arg("query"))
+            .define_method("to_string", &QUrlQuery::toString, Arg("encoding") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::PrettyDecoded));
+}

data/ext/qt6/qtcore/qurlquery-rb.hpp

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qurlquery(Module rb_mQt6QtCore);

data/ext/qt6/qtcore/t-qtcore-rb.cpp

@@ -2,6 +2,7 @@
 #include <rice/qt6/qlist.hpp>
 #include <rice/qt6/qmap.hpp>
 
+#include <QFileInfo>
 #include <QItemSelectionRange>
 #include <QModelIndex>
 #include <QString>
@@ -16,6 +17,9 @@ void Init_t_qtcore(Module rb_mQt6T)
     // QList<QByteArray>
     define_qlist_under<QByteArray>(rb_mQt6T);
 
+    // QList<QFileInfo>
+    define_qlist_under<QFileInfo>(rb_mQt6T);
+
     // QList<QItemSelectionRange> -> QItemSelection
     define_qlist_under<QItemSelectionRange>(rb_mQt6T);
 

data/lib/qt6/bando/dsl.rb

@@ -4,7 +4,7 @@ module RubyQt6
   module Bando
     # @!visibility private
     def self.define_bando_qobject(qlass)
-      unless qlass <= QtCore::QObject
+      unless qlass <= RubyQt6::QtCore::QObject
         raise "Invalid superclass: macro `define_bando_qobject` " \
           "only available for subclass of RubyQt6::QtCore::QObject"
       end
@@ -23,7 +23,7 @@ module RubyQt6
 
     # @!visibility private
     def self.define_bando_qwidget(qlass)
-      unless qlass <= QtWidgets::QWidget
+      unless qlass <= RubyQt6::QtWidgets::QWidget
         raise "Invalid superclass: macro `define_bando_qwidget` " \
           "only available for subclass of RubyQt6::QtWidgets::QWidget"
       end

data/lib/qt6/configuration.rb

@@ -2,15 +2,10 @@
 
 module RubyQt6
   # @!visibility private
-  def self.load_defaults
-    mods = RubyQt6.constants.grep(/^Qt/).map { |const| RubyQt6.const_get(const) }
-    mods.each do |mod|
-      mod.constants.each do |const|
-        next if const.match?("VERSION")
-        Object.const_set(const, mod.const_get(const)) if const.start_with?("Q")
-      end
+  def self.initialize!(mod)
+    mod.constants.each do |const|
+      next if const.match?("VERSION")
+      Object.const_set(const, mod.const_get(const)) if const.start_with?("Q")
     end
-
-    true
   end
 end

data/lib/qt6/ducktyping.rb

@@ -4,56 +4,56 @@ module RubyQt6
   # @!visibility private
   module T
     def self.args_nth_delete_qobject(args, index)
-      return unless args[index].is_a?(QtCore::QObject)
+      return unless args[index].is_a?(QObject)
       args.delete_at(index)
     end
 
     def self.args_nth_delete_qwidget(args, index)
-      return unless args[index].is_a?(QtWidgets::QWidget)
+      return unless args[index].is_a?(QWidget)
       args.delete_at(index)
     end
 
     def self.args_nth_delete_qgraphicsitem(args, index)
-      return unless args[index].is_a?(QtWidgets::QGraphicsItem)
+      return unless args[index].is_a?(QGraphicsItem)
       args.delete_at(index)
     end
 
     def self.args_nth_to_qanystringview(args, index)
-      return unless args[index].is_a?(String) || args[index].is_a?(QtCore::QString)
-      args[index] = QtCore::QAnyStringView.new(args[index])
+      return unless args[index].is_a?(String) || args[index].is_a?(QString)
+      args[index] = QAnyStringView.new(args[index])
     end
 
     def self.args_nth_to_qstr(args, index)
       return unless args[index].is_a?(String)
-      args[index] = QtCore::QString.new(args[index])
+      args[index] = QString.new(args[index])
     end
 
     def self.to_qanystringview(str)
-      return str unless str.is_a?(String) || str.is_a?(QtCore::QString)
-      QtCore::QAnyStringView.new(str)
+      return str unless str.is_a?(String) || str.is_a?(QString)
+      QAnyStringView.new(str)
     end
 
     def self.to_qbytearray(str)
       return str unless str.is_a?(String)
-      QtCore::QByteArray.new(str)
+      QByteArray.new(str)
     end
 
     def self.to_qstr(str)
       return str unless str.is_a?(String)
-      QtCore::QString.new(str)
+      QString.new(str)
     end
 
     def self.to_qkeysequence(key)
-      return key unless key.is_a?(String) || key.is_a?(QtCore::QString) || key.is_a?(Integer) || key.is_a?(QtGui::QKeySequence::StandardKey)
-      QtGui::QKeySequence.new(key)
+      return key unless key.is_a?(String) || key.is_a?(QString) || key.is_a?(Integer) || key.is_a?(QKeySequence::StandardKey)
+      QKeySequence.new(key)
     end
 
     def self.to_qvariantlist(array)
-      array.each_with_object(QtCore::QVariantList.new) { |e, memo| memo << QtCore::QVariant.new(e) }
+      array.each_with_object(QVariantList.new) { |e, memo| memo << QVariant.new(e) }
     end
 
     def self.to_qvariantmap(hash)
-      hash.each_with_object(QtCore::QVariantMap.new) { |(k, v), memo| memo[k.to_qstr] = QtCore::QVariant.new(v) }
+      hash.each_with_object(QVariantMap.new) { |(k, v), memo| memo[k.to_qstr] = QVariant.new(v) }
     end
 
     def self.to_qflags(enum_or_flags)

data/lib/qt6/qtcore/private/metaobject.rb

@@ -56,7 +56,7 @@ module RubyQt6
         end
 
         def super_class
-          return nil if @qlass == QtCore::QObject
+          return nil if @qlass == QObject
           @qlass.superclass._rubyqt6_metaobject
         end
 
@@ -67,7 +67,7 @@ module RubyQt6
         def to_qmetaobject
           return @qlass._static_meta_object unless ruby?
 
-          builder = QtCore::QMetaObjectBuilder.new
+          builder = QMetaObjectBuilder.new
           builder.set_class_name(@qlass.name)
           builder.set_super_class(@qlass.superclass._qmetaobject)
           @classinfo.each { |name, value| builder.add_class_info(name, value) }

data/lib/qt6/qtcore/private/signalmanager.rb

@@ -6,12 +6,12 @@ module RubyQt6
       class SignalManager
         def self.connect(sender, signal, receiver, metamethod)
           metamethod = QtCore::Private::MetaObject.find_receiver_metamethod!(receiver, metamethod, signal)
-          QtCore::QObject._connect(sender, signal.qsignature, receiver, metamethod.qsignature)
+          QObject._connect(sender, signal.qsignature, receiver, metamethod.qsignature)
         end
 
         def self.disconnect(sender, signal, receiver, metamethod)
           metamethod = QtCore::Private::MetaObject.find_receiver_metamethod!(receiver, metamethod, signal)
-          QtCore::QObject._disconnect(sender, signal.qsignature, receiver, metamethod.qsignature)
+          QObject._disconnect(sender, signal.qsignature, receiver, metamethod.qsignature)
         end
 
         def self.emit(sender, signal, *args)
@@ -20,9 +20,9 @@ module RubyQt6
 
           raise "Too many arguments" if qmetamethod.parameter_count < args.count
           raise "Not enough arguments" if qmetamethod.parameter_count > args.count
-          args = args.map.with_index { |arg, i| QtCore::QVariant.new(arg, qmetamethod.parameter_meta_type(i)) }
+          args = args.map.with_index { |arg, i| QVariant.new(arg, qmetamethod.parameter_meta_type(i)) }
 
-          QtCore::QObject._emit(sender, qmetamethod, args)
+          QObject._emit(sender, qmetamethod, args)
         end
       end
     end

data/lib/qt6/qtcore/qdate.rb

@@ -25,7 +25,7 @@ module RubyQt6
 
       # @!visibility private
       def to_s
-        _to_string(QtCore::Qt::RFC2822Date).to_s
+        _to_string(Qt::RFC2822Date).to_s
       end
 
       # @!visibility private