ruby-qt6-qtcore 1.0.1 → 2.0.1

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/qrect-rb.cpp

@@ -1,17 +1,19 @@
 #include "qrect-rb.hpp"
 #include <qrect.h>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-Rice::Class rb_cQRect;
-Rice::Class rb_cQRectF;
+Class rb_cQRect;
+Class rb_cQRectF;
 
-void Init_qrect(Rice::Module rb_mQt6QtCore)
+void Init_qrect(Module rb_mQt6QtCore)
 {
     rb_cQRect =
         // RubyQt6::QtCore::QRect
         define_class_under<QRect>(rb_mQt6QtCore, "QRect")
             // RubyQt6-Defined Functions
+            .define_method("+", [](QRect *self, QMargins *margins) -> QRect { return *self + *margins; })
+            .define_method("-", [](QRect *self, QMargins *margins) -> QRect { return *self - *margins; })
             .define_singleton_function("_operator_equal", [](QRect *lhs, QRect  *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
             .define_singleton_function("_operator_equal", [](QRect *lhs, QRectF *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
             // Constructor
@@ -88,6 +90,8 @@ void Init_qrect(Rice::Module rb_mQt6QtCore)
         // RubyQt6::QtCore::QRectF
         define_class_under<QRectF>(rb_mQt6QtCore, "QRectF")
             // RubyQt6-Defined Functions
+            .define_method("+", [](QRectF *self, QMarginsF *margins) -> QRectF { return *self + *margins; })
+            .define_method("-", [](QRectF *self, QMarginsF *margins) -> QRectF { return *self - *margins; })
             .define_singleton_function("_operator_equal", [](QRectF *lhs, QRect  *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
             .define_singleton_function("_operator_equal", [](QRectF *lhs, QRectF *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
             // Constructor

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

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qrect(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qrect(Module rb_mQt6QtCore);

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

@@ -3,12 +3,13 @@
 #include <rice/qt6/qenum.hpp>
 #include <rice/qt6/qflags.hpp>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-Rice::Class rb_cQRegularExpression;
-Rice::Class rb_cQRegularExpressionMatch;
+Class rb_cQRegularExpression;
+Class rb_cQRegularExpressionMatch;
+Class rb_cQRegularExpressionMatchIterator;
 
-void Init_qregularexpression(Rice::Module rb_mQt6QtCore)
+void Init_qregularexpression(Module rb_mQt6QtCore)
 {
     rb_cQRegularExpression =
         // RubyQt6::QtCore::QRegularExpression
@@ -111,4 +112,15 @@ void Init_qregularexpression(Rice::Module rb_mQt6QtCore)
             .define_method("match_options", &QRegularExpressionMatch::matchOptions)
             .define_method("match_type", &QRegularExpressionMatch::matchType)
             .define_method("regular_expression", &QRegularExpressionMatch::regularExpression);
+
+    rb_cQRegularExpressionMatchIterator =
+        // RubyQt6::QtCore::QRegularExpressionMatchIterator
+        define_class_under<QRegularExpressionMatchIterator>(rb_mQt6QtCore, "QRegularExpressionMatchIterator")
+            // Public Functions
+            .define_method("has_next", &QRegularExpressionMatchIterator::hasNext)
+            .define_method("match_options", &QRegularExpressionMatchIterator::matchOptions)
+            .define_method("match_type", &QRegularExpressionMatchIterator::matchType)
+            .define_method("next", &QRegularExpressionMatchIterator::next)
+            .define_method("peek_next", &QRegularExpressionMatchIterator::peekNext)
+            .define_method("regular_expression", &QRegularExpressionMatchIterator::regularExpression);
 }

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

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qregularexpression(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qregularexpression(Module rb_mQt6QtCore);

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

@@ -4,11 +4,11 @@
 
 #include <QDateTime>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-Rice::Class rb_cQResource;
+Class rb_cQResource;
 
-void Init_qresource(Rice::Module rb_mQt6QtCore)
+void Init_qresource(Module rb_mQt6QtCore)
 {
     rb_cQResource =
         // RubyQt6::QtCore::QResource

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

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qresource(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qresource(Module rb_mQt6QtCore);

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

@@ -2,11 +2,11 @@
 #include <qsettings.h>
 #include <rice/qt6/qenum.hpp>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-Rice::Class rb_cQSettings;
+Class rb_cQSettings;
 
-void Init_qsettings(Rice::Module rb_mQt6QtCore)
+void Init_qsettings(Module rb_mQt6QtCore)
 {
     rb_cQSettings =
         // RubyQt6::QtCore::QSettings

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

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qsettings(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qsettings(Module rb_mQt6QtCore);

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

@@ -1,11 +1,11 @@
 #include "qsignalmapper-rb.hpp"
 #include <qsignalmapper.h>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-Rice::Class rb_cQSignalMapper;
+Class rb_cQSignalMapper;
 
-void Init_qsignalmapper(Rice::Module rb_mQt6QtCore)
+void Init_qsignalmapper(Module rb_mQt6QtCore)
 {
     rb_cQSignalMapper =
         // RubyQt6::QtCore::QSignalMapper
@@ -24,9 +24,9 @@ void Init_qsignalmapper(Rice::Module rb_mQt6QtCore)
             .define_method<void (QSignalMapper::*)(QObject *, int)>("_set_mapping", &QSignalMapper::setMapping, Arg("sender"), Arg("id"))
             // Public Slots
             .define_method<void (QSignalMapper::*)()>("map", &QSignalMapper::map)
-            .define_method<void (QSignalMapper::*)(QObject *)>("map", &QSignalMapper::map, Arg("sender"))
+            .define_method<void (QSignalMapper::*)(QObject *)>("map", &QSignalMapper::map, Arg("sender"));
             // Signals
-            .define_method("mapped_int", &QSignalMapper::mappedInt, Arg("id"))
-            .define_method("mapped_object", &QSignalMapper::mappedObject, Arg("object"))
-            .define_method("mapped_string", &QSignalMapper::mappedString, Arg("text"));
+            // .define_method("mapped_int", &QSignalMapper::mappedInt, Arg("id"))
+            // .define_method("mapped_object", &QSignalMapper::mappedObject, Arg("object"))
+            // .define_method("mapped_string", &QSignalMapper::mappedString, Arg("text"));
 }

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

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qsignalmapper(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qsignalmapper(Module rb_mQt6QtCore);

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

@@ -1,12 +1,12 @@
 #include "qsize-rb.hpp"
 #include <qsize.h>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-Rice::Class rb_cQSize;
-Rice::Class rb_cQSizeF;
+Class rb_cQSize;
+Class rb_cQSizeF;
 
-void Init_qsize(Rice::Module rb_mQt6QtCore)
+void Init_qsize(Module rb_mQt6QtCore)
 {
     rb_cQSize =
         // RubyQt6::QtCore::QSize

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

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qsize(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qsize(Module rb_mQt6QtCore);

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

@@ -0,0 +1,61 @@
+#include "qstandardpaths-rb.hpp"
+#include <qstandardpaths.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+Class rb_cQStandardPaths;
+
+void Init_qstandardpaths(Module rb_mQt6QtCore)
+{
+    rb_cQStandardPaths =
+        // RubyQt6::QtCore::QStandardPaths
+        define_class_under<QStandardPaths>(rb_mQt6QtCore, "QStandardPaths")
+            // Static Public Members
+            .define_singleton_function("display_name", &QStandardPaths::displayName, Arg("type"))
+            .define_singleton_function("find_executable", &QStandardPaths::findExecutable, Arg("executable_name"), Arg("paths") = static_cast<const QStringList &>(QStringList()))
+            .define_singleton_function("test_mode_enabled?", &QStandardPaths::isTestModeEnabled)
+            .define_singleton_function("locate", &QStandardPaths::locate, Arg("type"), Arg("file_name"), Arg("options") = static_cast<QStandardPaths::LocateOptions>(QStandardPaths::LocateFile))
+            .define_singleton_function("locate_all", &QStandardPaths::locateAll, Arg("type"), Arg("file_name"), Arg("options") = static_cast<QStandardPaths::LocateOptions>(QStandardPaths::LocateFile))
+            .define_singleton_function("set_test_mode_enabled", &QStandardPaths::setTestModeEnabled, Arg("test_mode"))
+            .define_singleton_function("standard_locations", &QStandardPaths::standardLocations, Arg("type"))
+            .define_singleton_function("writable_location", &QStandardPaths::writableLocation, Arg("type"));
+
+    Data_Type<QStandardPaths::LocateOption> rb_cQStandardPathsLocateOption =
+        // RubyQt6::QtCore::QStandardPaths::LocateOption
+        define_qenum_under<QStandardPaths::LocateOption>(rb_cQStandardPaths, "LocateOption");
+        define_qenum_value_under(rb_cQStandardPathsLocateOption, "LocateFile", QStandardPaths::LocateOption::LocateFile);
+        define_qenum_value_under(rb_cQStandardPathsLocateOption, "LocateDirectory", QStandardPaths::LocateOption::LocateDirectory);
+
+    Data_Type<QStandardPaths::StandardLocation> rb_cQStandardPathsStandardLocation =
+        // RubyQt6::QtCore::QStandardPaths::StandardLocation
+        define_qenum_under<QStandardPaths::StandardLocation>(rb_cQStandardPaths, "StandardLocation");
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "DesktopLocation", QStandardPaths::StandardLocation::DesktopLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "DocumentsLocation", QStandardPaths::StandardLocation::DocumentsLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "FontsLocation", QStandardPaths::StandardLocation::FontsLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "ApplicationsLocation", QStandardPaths::StandardLocation::ApplicationsLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "MusicLocation", QStandardPaths::StandardLocation::MusicLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "MoviesLocation", QStandardPaths::StandardLocation::MoviesLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "PicturesLocation", QStandardPaths::StandardLocation::PicturesLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "TempLocation", QStandardPaths::StandardLocation::TempLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "HomeLocation", QStandardPaths::StandardLocation::HomeLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "AppLocalDataLocation", QStandardPaths::StandardLocation::AppLocalDataLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "CacheLocation", QStandardPaths::StandardLocation::CacheLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "GenericDataLocation", QStandardPaths::StandardLocation::GenericDataLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "RuntimeLocation", QStandardPaths::StandardLocation::RuntimeLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "ConfigLocation", QStandardPaths::StandardLocation::ConfigLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "DownloadLocation", QStandardPaths::StandardLocation::DownloadLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "GenericCacheLocation", QStandardPaths::StandardLocation::GenericCacheLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "GenericConfigLocation", QStandardPaths::StandardLocation::GenericConfigLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "AppDataLocation", QStandardPaths::StandardLocation::AppDataLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "AppConfigLocation", QStandardPaths::StandardLocation::AppConfigLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "PublicShareLocation", QStandardPaths::StandardLocation::PublicShareLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "TemplatesLocation", QStandardPaths::StandardLocation::TemplatesLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "StateLocation", QStandardPaths::StandardLocation::StateLocation);
+        define_qenum_value_under(rb_cQStandardPathsStandardLocation, "GenericStateLocation", QStandardPaths::StandardLocation::GenericStateLocation);
+
+    Data_Type<QFlags<QStandardPaths::LocateOption>> rb_cQStandardPathsLocateOptions =
+        // RubyQt6::QtCore::QStandardPaths::LocateOptions
+        define_qflags_under<QStandardPaths::LocateOption>(rb_cQStandardPaths, "LocateOptions");
+}

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

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

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

@@ -3,9 +3,9 @@
 
 #include <QRegularExpression>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-Rice::Class rb_cQString;
+Class rb_cQString;
 
 std::optional<QString> QString_slice(QString *self, qsizetype start, qsizetype length)
 {
@@ -37,7 +37,7 @@ QString QString_replace(QString *self, qsizetype start, const QString &after)
     return self->replace(start, 1, after);
 }
 
-void Init_qstring(Rice::Module rb_mQt6QtCore)
+void Init_qstring(Module rb_mQt6QtCore)
 {
     rb_cQString =
         // RubyQt6::QtCore::QString
@@ -62,6 +62,8 @@ void Init_qstring(Rice::Module rb_mQt6QtCore)
             .define_method("to_std_string", &QString::toStdString)
             .define_method<bool (QString::*)(const QRegularExpression &, QRegularExpressionMatch *) const>("_contains", &QString::contains, Arg("re"), Arg("rmatch") = static_cast<QRegularExpressionMatch *>(nullptr))
             .define_method<bool (QString::*)(const QString &, Qt::CaseSensitivity) const>("_contains", &QString::contains, Arg("s"), Arg("cs") = static_cast<Qt::CaseSensitivity>(Qt::CaseSensitive))
+            .define_method<qsizetype (QString::*)(const QString &, qsizetype, Qt::CaseSensitivity) const>("_index_of", &QString::indexOf, Arg("s"), Arg("from") = static_cast<qsizetype>(0), Arg("cs") = static_cast<Qt::CaseSensitivity>(Qt::CaseSensitive))
+            .define_method<qsizetype (QString::*)(const QRegularExpression &, qsizetype, QRegularExpressionMatch *) const>("_index_of", &QString::indexOf, Arg("re"), Arg("from") = static_cast<qsizetype>(0), Arg("rmatch") = static_cast<QRegularExpressionMatch *>(nullptr))
             .define_method<QStringList (QString::*)(const QString &, Qt::SplitBehavior, Qt::CaseSensitivity) const>("_split", &QString::split, Arg("sep"), Arg("behavior") = static_cast<Qt::SplitBehavior>(Qt::KeepEmptyParts), Arg("cs") = static_cast<Qt::CaseSensitivity>(Qt::CaseSensitive))
             .define_method<QStringList (QString::*)(const QRegularExpression &, Qt::SplitBehavior) const>("_split", &QString::split, Arg("sep"), Arg("behavior") = static_cast<Qt::SplitBehavior>(Qt::KeepEmptyParts));
 }

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

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qstring(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qstring(Module rb_mQt6QtCore);

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

@@ -3,51 +3,15 @@
 
 #include <QList>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-Rice::Class rb_cQStringList;
+Class rb_cQStringList;
 
-void Init_qstringlist(Rice::Module rb_mQt6QtCore)
+void Init_qstringlist(Module rb_mQt6QtCore)
 {
     rb_cQStringList =
         // RubyQt6::QtCore::QStringList
         define_class_under<QStringList, QList<QString>>(rb_mQt6QtCore, "QStringList")
-            .define_method("count", [](QStringList *self, const char *str) -> qsizetype {
-                Data_Object<QStringList> self_(self);
-                auto r = self_.call("count", QString(str));
-                return detail::From_Ruby<qsizetype>().convert(r);
-            })
-            .define_method("include?", [](QStringList *self, const char *str) -> bool {
-                Data_Object<QStringList> self_(self);
-                auto r = self_.call("include?", QString(str));
-                return detail::From_Ruby<bool>().convert(r);
-            })
-            .define_method("index", [](QStringList *self, const char *str) -> std::optional<qsizetype> {
-                Data_Object<QStringList> self_(self);
-                auto r = self_.call("index", QString(str));
-                return detail::From_Ruby<std::optional<qsizetype>>().convert(r);
-            })
-            .define_method("insert", [](QStringList *self, qsizetype index, const char *str) -> QStringList * {
-                Data_Object<QStringList> self_(self);
-                auto _ = self_.call("insert", index, QString(str));
-                return self;
-            })
-            .define_method("push", [](QStringList *self, const char * str) -> QStringList * {
-                Data_Object<QStringList> self_(self);
-                auto _ = self_.call("push", QString(str));
-                return self;
-            })
-            .define_method("delete", [](QStringList *self, const char * str) -> std::optional<QString> {
-                Data_Object<QStringList> self_(self);
-                auto r = self_.call("delete", QString(str));
-                return detail::From_Ruby<std::optional<QString>>().convert(r);
-            })
-            .define_method("[]=", [](QStringList *self, qsizetype index, const char *str) -> QString {
-                Data_Object<QStringList> self_(self);
-                auto r = self_.call("[]=", index, QString(str));
-                return detail::From_Ruby<QString>().convert(r);
-            })
-            .define_method("_join", [](QStringList *self, QString &separator) -> QString {
-                return self->join(separator);
-            });
+            .define_method("join", [](QStringList *self, const char *separator) -> QString { return self->join(separator); }, Arg("separator") = static_cast<const char *>(nullptr))
+            .define_method("join", [](QStringList *self, QString &separator) -> QString { return self->join(separator); }, Arg("separator") = static_cast<const QString &>(QString()));
 }

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

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qstringlist(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qstringlist(Module rb_mQt6QtCore);

data/ext/qt6/qtcore/qt-enum-af-rb.cpp

@@ -2,9 +2,9 @@
 #include <qnamespace.h>
 #include <rice/qt6/qenum.hpp>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-void Init_qt_enum_af(Rice::Module rb_mQt6QtCore)
+void Init_qt_enum_af(Module rb_mQt6QtCore)
 {
     Module rb_mQt =
         // RubyQt6::QtCore::Qt

data/ext/qt6/qtcore/qt-enum-af-rb.hpp

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qt_enum_af(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qt_enum_af(Module rb_mQt6QtCore);

data/ext/qt6/qtcore/qt-enum-gl-rb.cpp

@@ -2,9 +2,9 @@
 #include <qnamespace.h>
 #include <rice/qt6/qenum.hpp>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-void Init_qt_enum_gl(Rice::Module rb_mQt6QtCore)
+void Init_qt_enum_gl(Module rb_mQt6QtCore)
 {
     Module rb_mQt =
         // RubyQt6::QtCore::Qt

data/ext/qt6/qtcore/qt-enum-gl-rb.hpp

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qt_enum_gl(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qt_enum_gl(Module rb_mQt6QtCore);

data/ext/qt6/qtcore/qt-enum-mr-rb.cpp

@@ -2,9 +2,9 @@
 #include <qnamespace.h>
 #include <rice/qt6/qenum.hpp>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
-void Init_qt_enum_mr(Rice::Module rb_mQt6QtCore)
+void Init_qt_enum_mr(Module rb_mQt6QtCore)
 {
     Module rb_mQt =
         // RubyQt6::QtCore::Qt

data/ext/qt6/qtcore/qt-enum-mr-rb.hpp

@@ -1,4 +1,5 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
+#include <rice/qt6.hpp>
 
-void Init_qt_enum_mr(Rice::Module rb_mQt6QtCore);
+RICE4RUBYQT6_USE_NAMESPACE
+
+void Init_qt_enum_mr(Module rb_mQt6QtCore);