ruby-qt6-qtcore 1.0.0

data/ext/qt6/qtcore/qt-flags-al-rb.cpp

@@ -0,0 +1,61 @@
+#include "qt-flags-al-rb.hpp"
+#include <qnamespace.h>
+
+#include <rice/qt6/qflags.hpp>
+
+using namespace Rice;
+
+void Init_qt_flags_al(Rice::Module rb_mQt6QtCore)
+{
+    Module rb_mQt =
+        // RubyQt6::QtCore::Qt
+        define_module_under(rb_mQt6QtCore, "Qt");
+
+    Data_Type<QFlags<Qt::AlignmentFlag>> rb_cQtAlignment =
+        // RubyQt6::QtCore::Qt::Alignment
+        define_qflags_under<Qt::AlignmentFlag>(rb_mQt, "Alignment");
+
+    Data_Type<QFlags<Qt::ApplicationState>> rb_cQtApplicationStates =
+        // RubyQt6::QtCore::Qt::ApplicationStates
+        define_qflags_under<Qt::ApplicationState>(rb_mQt, "ApplicationStates");
+
+    Data_Type<QFlags<Qt::DockWidgetArea>> rb_cQtDockWidgetAreas =
+        // RubyQt6::QtCore::Qt::DockWidgetAreas
+        define_qflags_under<Qt::DockWidgetArea>(rb_mQt, "DockWidgetAreas");
+
+    Data_Type<QFlags<Qt::DropAction>> rb_cQtDropActions =
+        // RubyQt6::QtCore::Qt::DropActions
+        define_qflags_under<Qt::DropAction>(rb_mQt, "DropActions");
+
+    Data_Type<QFlags<Qt::Edge>> rb_cQtEdges =
+        // RubyQt6::QtCore::Qt::Edges
+        define_qflags_under<Qt::Edge>(rb_mQt, "Edges");
+
+    Data_Type<QFlags<Qt::FindChildOption>> rb_cQtFindChildOptions =
+        // RubyQt6::QtCore::Qt::FindChildOptions
+        define_qflags_under<Qt::FindChildOption>(rb_mQt, "FindChildOptions");
+
+    Data_Type<QFlags<Qt::GestureFlag>> rb_cQtGestureFlags =
+        // RubyQt6::QtCore::Qt::GestureFlags
+        define_qflags_under<Qt::GestureFlag>(rb_mQt, "GestureFlags");
+
+    Data_Type<QFlags<Qt::ImageConversionFlag>> rb_cQtImageConversionFlags =
+        // RubyQt6::QtCore::Qt::ImageConversionFlags
+        define_qflags_under<Qt::ImageConversionFlag>(rb_mQt, "ImageConversionFlags");
+
+    Data_Type<QFlags<Qt::InputMethodHint>> rb_cQtInputMethodHints =
+        // RubyQt6::QtCore::Qt::InputMethodHints
+        define_qflags_under<Qt::InputMethodHint>(rb_mQt, "InputMethodHints");
+
+    Data_Type<QFlags<Qt::InputMethodQuery>> rb_cQtInputMethodQueries =
+        // RubyQt6::QtCore::Qt::InputMethodQueries
+        define_qflags_under<Qt::InputMethodQuery>(rb_mQt, "InputMethodQueries");
+
+    Data_Type<QFlags<Qt::ItemFlag>> rb_cQtItemFlags =
+        // RubyQt6::QtCore::Qt::ItemFlags
+        define_qflags_under<Qt::ItemFlag>(rb_mQt, "ItemFlags");
+
+    Data_Type<QFlags<Qt::KeyboardModifier>> rb_cQtKeyboardModifiers =
+        // RubyQt6::QtCore::Qt::KeyboardModifiers
+        define_qflags_under<Qt::KeyboardModifier>(rb_mQt, "KeyboardModifiers");
+}

data/ext/qt6/qtcore/qt-flags-al-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qt_flags_al(Rice::Module rb_mQt6QtCore);

data/ext/qt6/qtcore/qt-flags-mz-rb.cpp

@@ -0,0 +1,61 @@
+#include "qt-flags-mz-rb.hpp"
+#include <qnamespace.h>
+
+#include <rice/qt6/qflags.hpp>
+
+using namespace Rice;
+
+void Init_qt_flags_mz(Rice::Module rb_mQt6QtCore)
+{
+    Module rb_mQt =
+        // RubyQt6::QtCore::Qt
+        define_module_under(rb_mQt6QtCore, "Qt");
+
+    Data_Type<QFlags<Qt::MatchFlag>> rb_cQtMatchFlags =
+        // RubyQt6::QtCore::Qt::MatchFlags
+        define_qflags_under<Qt::MatchFlag>(rb_mQt, "MatchFlags");
+
+    Data_Type<QFlags<Qt::Modifier>> rb_cQtModifiers =
+        // RubyQt6::QtCore::Qt::Modifiers
+        define_qflags_under<Qt::Modifier>(rb_mQt, "Modifiers");
+
+    Data_Type<QFlags<Qt::MouseButton>> rb_cQtMouseButtons =
+        // RubyQt6::QtCore::Qt::MouseButtons
+        define_qflags_under<Qt::MouseButton>(rb_mQt, "MouseButtons");
+
+    Data_Type<QFlags<Qt::MouseEventFlag>> rb_cQtMouseEventFlags =
+        // RubyQt6::QtCore::Qt::MouseEventFlags
+        define_qflags_under<Qt::MouseEventFlag>(rb_mQt, "MouseEventFlags");
+
+    Data_Type<QFlags<Qt::Orientation>> rb_cQtOrientations =
+        // RubyQt6::QtCore::Qt::Orientations
+        define_qflags_under<Qt::Orientation>(rb_mQt, "Orientations");
+
+    Data_Type<QFlags<Qt::ScreenOrientation>> rb_cQtScreenOrientations =
+        // RubyQt6::QtCore::Qt::ScreenOrientations
+        define_qflags_under<Qt::ScreenOrientation>(rb_mQt, "ScreenOrientations");
+
+    Data_Type<QFlags<Qt::SplitBehaviorFlags>> rb_cQtSplitBehavior =
+        // RubyQt6::QtCore::Qt::SplitBehavior
+        define_qflags_under<Qt::SplitBehaviorFlags>(rb_mQt, "SplitBehavior");
+
+    Data_Type<QFlags<Qt::TextInteractionFlag>> rb_cQtTextInteractionFlags =
+        // RubyQt6::QtCore::Qt::TextInteractionFlags
+        define_qflags_under<Qt::TextInteractionFlag>(rb_mQt, "TextInteractionFlags");
+
+    Data_Type<QFlags<Qt::ToolBarArea>> rb_cQtToolBarAreas =
+        // RubyQt6::QtCore::Qt::ToolBarAreas
+        define_qflags_under<Qt::ToolBarArea>(rb_mQt, "ToolBarAreas");
+
+    Data_Type<QFlags<Qt::TouchPointState>> rb_cQtTouchPointStates =
+        // RubyQt6::QtCore::Qt::TouchPointStates
+        define_qflags_under<Qt::TouchPointState>(rb_mQt, "TouchPointStates");
+
+    Data_Type<QFlags<Qt::WindowState>> rb_cQtWindowStates =
+        // RubyQt6::QtCore::Qt::WindowStates
+        define_qflags_under<Qt::WindowState>(rb_mQt, "WindowStates");
+
+    Data_Type<QFlags<Qt::WindowType>> rb_cQtWindowFlags =
+        // RubyQt6::QtCore::Qt::WindowFlags
+        define_qflags_under<Qt::WindowType>(rb_mQt, "WindowFlags");
+}

data/ext/qt6/qtcore/qt-flags-mz-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qt_flags_mz(Rice::Module rb_mQt6QtCore);

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

@@ -0,0 +1,130 @@
+#include "qtcore-rb.hpp"
+#include "qtcoreversion-rb.hpp"
+#include "qt-enum-af-rb.hpp"
+#include "qt-enum-gl-rb.hpp"
+#include "qt-enum-mr-rb.hpp"
+#include "qt-enum-sz-rb.hpp"
+#include "qt-flags-al-rb.hpp"
+#include "qt-flags-mz-rb.hpp"
+
+#include "qmetaclassinfo-rb.hpp"
+#include "qmetamethod-rb.hpp"
+#include "qmetaobject-rb.hpp"
+#include "qmetaobjectbuilder-rb.hpp"
+#include "qmetatype-rb.hpp"
+
+#include "qanystringview-rb.hpp"
+#include "qbytearray-rb.hpp"
+#include "qchar-rb.hpp"
+#include "qstring-rb.hpp"
+#include "qiodevicebase-rb.hpp"
+
+#include "qbasictimer-rb.hpp"
+#include "qcoreevent-rb.hpp"
+#include "qdatetime-rb.hpp"
+#include "qdir-rb.hpp"
+#include "qfileinfo-rb.hpp"
+#include "qlibraryinfo-rb.hpp"
+#include "qline-rb.hpp"
+#include "qlocale-rb.hpp"
+#include "qmargins-rb.hpp"
+#include "qmodelindex-rb.hpp"
+#include "qpoint-rb.hpp"
+#include "qrect-rb.hpp"
+#include "qregularexpression-rb.hpp"
+#include "qresource-rb.hpp"
+#include "qsize-rb.hpp"
+#include "qtextstream-rb.hpp"
+#include "qurl-rb.hpp"
+#include "quuid-rb.hpp"
+#include "qvariant-rb.hpp"
+
+#include "qobject-rb.hpp"
+#include "qabstractitemmodel-rb.hpp"
+#include "qcoreapplication-rb.hpp"
+#include "qiodevice-rb.hpp"
+#include "qfiledevice-rb.hpp"
+#include "qfile-rb.hpp"
+#include "qitemselectionmodel-rb.hpp"
+#include "qsettings-rb.hpp"
+#include "qsignalmapper-rb.hpp"
+#include "qtimer-rb.hpp"
+#include "qtranslator-rb.hpp"
+
+#include "t-qtcore-rb.hpp"
+#include "qitemselection-rb.hpp"
+#include "qstringlist-rb.hpp"
+
+#include "bando-rb.hpp"
+#include "bando-qobject-rb.hpp"
+
+extern "C" void Init_qtcore()
+{
+    return Rice::detail::cpp_protect([] {
+        Rice::define_buffer<char *>();
+
+        Rice::Module rb_mQt6 = Rice::define_module("RubyQt6");
+        Rice::Module rb_mQt6QtCore = define_module_under(rb_mQt6, "QtCore");
+
+        Init_qtcoreversion(rb_mQt6QtCore);
+        Init_qt_enum_af(rb_mQt6QtCore);
+        Init_qt_enum_gl(rb_mQt6QtCore);
+        Init_qt_enum_mr(rb_mQt6QtCore);
+        Init_qt_enum_sz(rb_mQt6QtCore);
+        Init_qt_flags_al(rb_mQt6QtCore);
+        Init_qt_flags_mz(rb_mQt6QtCore);
+
+        Init_qmetaclassinfo(rb_mQt6QtCore);
+        Init_qmetamethod(rb_mQt6QtCore);
+        Init_qmetaobject(rb_mQt6QtCore);
+        Init_qmetaobjectbuilder(rb_mQt6QtCore);
+        Init_qmetatype(rb_mQt6QtCore);
+
+        Init_qanystringview(rb_mQt6QtCore);
+        Init_qbytearray(rb_mQt6QtCore);
+        Init_qchar(rb_mQt6QtCore);
+        Init_qstring(rb_mQt6QtCore);
+        Init_qiodevicebase(rb_mQt6QtCore);
+
+        Init_qbasictimer(rb_mQt6QtCore);
+        Init_qcoreevent(rb_mQt6QtCore);
+        Init_qdatetime(rb_mQt6QtCore);
+        Init_qdir(rb_mQt6QtCore);
+        Init_qfileinfo(rb_mQt6QtCore);
+        Init_qlibraryinfo(rb_mQt6QtCore);
+        Init_qline(rb_mQt6QtCore);
+        Init_qlocale(rb_mQt6QtCore);
+        Init_qmargins(rb_mQt6QtCore);
+        Init_qmodelindex(rb_mQt6QtCore);
+        Init_qpoint(rb_mQt6QtCore);
+        Init_qrect(rb_mQt6QtCore);
+        Init_qregularexpression(rb_mQt6QtCore);
+        Init_qresource(rb_mQt6QtCore);
+        Init_qsize(rb_mQt6QtCore);
+        Init_qtextstream(rb_mQt6QtCore);
+        Init_qurl(rb_mQt6QtCore);
+        Init_quuid(rb_mQt6QtCore);
+        Init_qvariant(rb_mQt6QtCore);
+
+        Init_qobject(rb_mQt6QtCore);
+        Init_qabstractitemmodel(rb_mQt6QtCore);
+        Init_qcoreapplication(rb_mQt6QtCore);
+        Init_qiodevice(rb_mQt6QtCore);
+        Init_qfiledevice(rb_mQt6QtCore);
+        Init_qfile(rb_mQt6QtCore);
+        Init_qitemselectionmodel(rb_mQt6QtCore);
+        Init_qsettings(rb_mQt6QtCore);
+        Init_qsignalmapper(rb_mQt6QtCore);
+        Init_qtimer(rb_mQt6QtCore);
+        Init_qtranslator(rb_mQt6QtCore);
+
+        Rice::Module rb_mQt6T = define_module_under(rb_mQt6, "T");
+        Init_t_qtcore(rb_mQt6T);
+        Init_qitemselection(rb_mQt6QtCore);
+        Init_qstringlist(rb_mQt6QtCore);
+
+        Rice::Module rb_mQt6Bando = define_module_under(rb_mQt6, "Bando");
+        Init_bando(rb_mQt6Bando);
+        Init_bando_qobject(rb_mQt6Bando);
+    });
+}

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

@@ -0,0 +1,3 @@
+#include <rice/rice.hpp>
+
+extern "C" void Init_qtcore();

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

@@ -0,0 +1,9 @@
+#include "qtcoreversion-rb.hpp"
+#include <qtcoreversion.h>
+
+using namespace Rice;
+
+void Init_qtcoreversion(Rice::Module rb_mQt6QtCore)
+{
+    rb_mQt6QtCore.define_constant("QTCORE_VERSION", QTCORE_VERSION_STR);
+}

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

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qtcoreversion(Rice::Module rb_mQt6QtCore);

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

@@ -0,0 +1,99 @@
+#include "qtextstream-rb.hpp"
+#include <qtextstream.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QIODevice>
+#include <QLocale>
+
+using namespace Rice;
+
+Rice::Class rb_cQTextStream;
+
+void Init_qtextstream(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQTextStream =
+        // RubyQt6::QtCore::QTextStream
+        define_class_under<QTextStream, QIODeviceBase>(rb_mQt6QtCore, "QTextStream")
+            // Constructor
+            .define_constructor(Constructor<QTextStream>())
+            .define_constructor(Constructor<QTextStream, QIODevice *>(), Arg("device"))
+            // Public Functions
+            .define_method("at_end", &QTextStream::atEnd)
+            .define_method("auto_detect_unicode", &QTextStream::autoDetectUnicode)
+            .define_method("device", &QTextStream::device)
+            .define_method("encoding", &QTextStream::encoding)
+            .define_method("field_alignment", &QTextStream::fieldAlignment)
+            .define_method("field_width", &QTextStream::fieldWidth)
+            .define_method("flush", &QTextStream::flush)
+            .define_method("generate_byte_order_mark", &QTextStream::generateByteOrderMark)
+            .define_method("integer_base", &QTextStream::integerBase)
+            .define_method("locale", &QTextStream::locale)
+            .define_method("number_flags", &QTextStream::numberFlags)
+            .define_method("pad_char", &QTextStream::padChar)
+            .define_method("pos", &QTextStream::pos)
+            .define_method("read", &QTextStream::read, Arg("maxlen"))
+            .define_method("read_all", &QTextStream::readAll)
+            .define_method("read_line", &QTextStream::readLine, Arg("maxlen") = static_cast<qint64>(0))
+            .define_method("read_line_into", &QTextStream::readLineInto, Arg("line"), Arg("maxlen") = static_cast<qint64>(0))
+            .define_method("real_number_notation", &QTextStream::realNumberNotation)
+            .define_method("real_number_precision", &QTextStream::realNumberPrecision)
+            .define_method("reset", &QTextStream::reset)
+            .define_method("reset_status", &QTextStream::resetStatus)
+            .define_method("seek", &QTextStream::seek, Arg("pos"))
+            .define_method("set_auto_detect_unicode", &QTextStream::setAutoDetectUnicode, Arg("enabled"))
+            .define_method("set_device", &QTextStream::setDevice, Arg("device"))
+            .define_method("set_encoding", &QTextStream::setEncoding, Arg("encoding"))
+            .define_method("set_field_alignment", &QTextStream::setFieldAlignment, Arg("alignment"))
+            .define_method("set_field_width", &QTextStream::setFieldWidth, Arg("width"))
+            .define_method("set_generate_byte_order_mark", &QTextStream::setGenerateByteOrderMark, Arg("generate"))
+            .define_method("set_integer_base", &QTextStream::setIntegerBase, Arg("base"))
+            .define_method("set_locale", &QTextStream::setLocale, Arg("locale"))
+            .define_method("set_number_flags", &QTextStream::setNumberFlags, Arg("flags"))
+            .define_method("set_pad_char", &QTextStream::setPadChar, Arg("ch"))
+            .define_method("set_real_number_notation", &QTextStream::setRealNumberNotation, Arg("notation"))
+            .define_method("set_real_number_precision", &QTextStream::setRealNumberPrecision, Arg("precision"))
+            .define_method("set_status", &QTextStream::setStatus, Arg("status"))
+            .define_method("set_string", &QTextStream::setString, Arg("string"), Arg("open_mode") = static_cast<QIODeviceBase::OpenMode>(QIODeviceBase::OpenModeFlag::ReadWrite))
+            .define_method("skip_white_space", &QTextStream::skipWhiteSpace)
+            .define_method("status", &QTextStream::status)
+            .define_method("string", &QTextStream::string)
+            .define_method<QTextStream &(QTextStream::*)(const char *)>("<<", &QTextStream::operator<<, Arg("s"))
+            .define_method<QTextStream &(QTextStream::*)(const QString &)>("<<", &QTextStream::operator<<, Arg("s"));
+
+    Data_Type<QTextStream::FieldAlignment> rb_cQTextStreamFieldAlignment =
+        // RubyQt6::QtCore::QTextStream::FieldAlignment
+        define_qenum_under<QTextStream::FieldAlignment>(rb_cQTextStream, "FieldAlignment");
+        define_qenum_value_under(rb_cQTextStreamFieldAlignment, "AlignLeft", QTextStream::FieldAlignment::AlignLeft);
+        define_qenum_value_under(rb_cQTextStreamFieldAlignment, "AlignRight", QTextStream::FieldAlignment::AlignRight);
+        define_qenum_value_under(rb_cQTextStreamFieldAlignment, "AlignCenter", QTextStream::FieldAlignment::AlignCenter);
+        define_qenum_value_under(rb_cQTextStreamFieldAlignment, "AlignAccountingStyle", QTextStream::FieldAlignment::AlignAccountingStyle);
+
+    Data_Type<QTextStream::NumberFlag> rb_cQTextStreamNumberFlag =
+        // RubyQt6::QtCore::QTextStream::NumberFlag
+        define_qenum_under<QTextStream::NumberFlag>(rb_cQTextStream, "NumberFlag");
+        define_qenum_value_under(rb_cQTextStreamNumberFlag, "ShowBase", QTextStream::NumberFlag::ShowBase);
+        define_qenum_value_under(rb_cQTextStreamNumberFlag, "ForcePoint", QTextStream::NumberFlag::ForcePoint);
+        define_qenum_value_under(rb_cQTextStreamNumberFlag, "ForceSign", QTextStream::NumberFlag::ForceSign);
+        define_qenum_value_under(rb_cQTextStreamNumberFlag, "UppercaseBase", QTextStream::NumberFlag::UppercaseBase);
+        define_qenum_value_under(rb_cQTextStreamNumberFlag, "UppercaseDigits", QTextStream::NumberFlag::UppercaseDigits);
+
+    Data_Type<QTextStream::RealNumberNotation> rb_cQTextStreamRealNumberNotation =
+        // RubyQt6::QtCore::QTextStream::RealNumberNotation
+        define_qenum_under<QTextStream::RealNumberNotation>(rb_cQTextStream, "RealNumberNotation");
+        define_qenum_value_under(rb_cQTextStreamRealNumberNotation, "SmartNotation", QTextStream::RealNumberNotation::SmartNotation);
+        define_qenum_value_under(rb_cQTextStreamRealNumberNotation, "FixedNotation", QTextStream::RealNumberNotation::FixedNotation);
+        define_qenum_value_under(rb_cQTextStreamRealNumberNotation, "ScientificNotation", QTextStream::RealNumberNotation::ScientificNotation);
+
+    Data_Type<QTextStream::Status> rb_cQTextStreamStatus =
+        // RubyQt6::QtCore::QTextStream::Status
+        define_qenum_under<QTextStream::Status>(rb_cQTextStream, "Status");
+        define_qenum_value_under(rb_cQTextStreamStatus, "Ok", QTextStream::Status::Ok);
+        define_qenum_value_under(rb_cQTextStreamStatus, "ReadPastEnd", QTextStream::Status::ReadPastEnd);
+        define_qenum_value_under(rb_cQTextStreamStatus, "ReadCorruptData", QTextStream::Status::ReadCorruptData);
+        define_qenum_value_under(rb_cQTextStreamStatus, "WriteFailed", QTextStream::Status::WriteFailed);
+
+    Data_Type<QFlags<QTextStream::NumberFlag>> rb_cQTextStreamNumberFlags =
+        // RubyQt6::QtCore::QTextStream::NumberFlags
+        define_qflags_under<QTextStream::NumberFlag>(rb_cQTextStream, "NumberFlags");
+}

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

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qtextstream(Rice::Module rb_mQt6QtCore);

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

@@ -0,0 +1,47 @@
+#include "qtimer-rb.hpp"
+#include <qtimer.h>
+
+#include <QBindable>
+
+using namespace Rice;
+
+Rice::Class rb_cQTimer;
+
+void Init_qtimer(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQTimer =
+        // RubyQt6::QtCore::QTimer
+        define_class_under<QTimer, QObject>(rb_mQt6QtCore, "QTimer")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QTimer::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QTimer, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("bindable_active", &QTimer::bindableActive)
+            .define_method("bindable_interval", &QTimer::bindableInterval)
+            .define_method("bindable_single_shot", &QTimer::bindableSingleShot)
+            .define_method("bindable_timer_type", &QTimer::bindableTimerType)
+            .define_method("id", &QTimer::id)
+            .define_method("interval", &QTimer::interval)
+            .define_method("interval_as_duration", &QTimer::intervalAsDuration)
+            .define_method("active?", &QTimer::isActive)
+            .define_method("single_shot?", &QTimer::isSingleShot)
+            .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
+            .define_method<void (QTimer::*)(int)>("start", &QTimer::start, Arg("msec"))
+            .define_method<void (QTimer::*)()>("start", &QTimer::start)
+            .define_method("stop", &QTimer::stop)
+            // Signals
+            .define_method("timeout", &QTimer::timeout)
+            // Static Public Members
+            .define_singleton_function<void (*)(int, Qt::TimerType, const QObject *, const char *)>("_single_shot", &QTimer::singleShot, Arg("msec"), Arg("timer_type"), Arg("receiver"), Arg("member"))
+            .define_singleton_function<void (*)(int, const QObject *, const char *)>("_single_shot", &QTimer::singleShot, Arg("msec"), Arg("receiver"), Arg("member"));
+}

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

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qtimer(Rice::Module rb_mQt6QtCore);

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

@@ -0,0 +1,26 @@
+#include "qtranslator-rb.hpp"
+#include <qtranslator.h>
+
+#include <QLocale>
+
+using namespace Rice;
+
+Rice::Class rb_cQTranslator;
+
+void Init_qtranslator(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQTranslator =
+        // RubyQt6::QtCore::QTranslator
+        define_class_under<QTranslator, QObject>(rb_mQt6QtCore, "QTranslator")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QTranslator::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QTranslator, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("file_path", &QTranslator::filePath)
+            .define_method("empty?", &QTranslator::isEmpty)
+            .define_method("language", &QTranslator::language)
+            .define_method<bool (QTranslator::*)(const QLocale &, const QString &, const QString &, const QString &, const QString &)>("_load", &QTranslator::load, Arg("locale"), Arg("filename"), Arg("prefix") = static_cast<const QString &>(QString()), Arg("directory") = static_cast<const QString &>(QString()), Arg("suffix") = static_cast<const QString &>(QString()))
+            .define_method<bool (QTranslator::*)(const QString &, const QString &, const QString &, const QString &)>("_load", &QTranslator::load, Arg("filename"), Arg("directory") = static_cast<const QString &>(QString()), Arg("search_delimiters") = static_cast<const QString &>(QString()), Arg("suffix") = static_cast<const QString &>(QString()))
+            .define_method("translate", &QTranslator::translate, Arg("context"), Arg("source_text"), Arg("disambiguation") = static_cast<const char *>(nullptr), Arg("n") = static_cast<int>(-1));
+}

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

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qtranslator(Rice::Module rb_mQt6QtCore);

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

@@ -0,0 +1,140 @@
+#include "qurl-rb.hpp"
+#include <qurl.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QUrlQuery>
+
+using namespace Rice;
+
+Rice::Class rb_cQUrl;
+
+void Init_qurl(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQUrl =
+        // RubyQt6::QtCore::QUrl
+        define_class_under<QUrl>(rb_mQt6QtCore, "QUrl")
+            // Constructor
+            .define_constructor(Constructor<QUrl>())
+            .define_constructor(Constructor<QUrl, const QString &>(), Arg("url"))
+            .define_constructor(Constructor<QUrl, const QString &, QUrl::ParsingMode>(), Arg("url"), Arg("mode"))
+            // Public Functions
+            .define_method("adjusted", &QUrl::adjusted, Arg("options"))
+            .define_method("authority", &QUrl::authority, Arg("options") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::ComponentFormattingOption::PrettyDecoded))
+            .define_method("clear", &QUrl::clear)
+            .define_method("detach", &QUrl::detach)
+            .define_method("error_string", &QUrl::errorString)
+            .define_method("file_name", &QUrl::fileName, Arg("options") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::ComponentFormattingOption::FullyDecoded))
+            .define_method("fragment", &QUrl::fragment, Arg("options") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::ComponentFormattingOption::PrettyDecoded))
+            .define_method("has_fragment", &QUrl::hasFragment)
+            .define_method("has_query", &QUrl::hasQuery)
+            .define_method("host", &QUrl::host, Arg("options") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::ComponentFormattingOption::FullyDecoded))
+            .define_method("detached?", &QUrl::isDetached)
+            .define_method("empty?", &QUrl::isEmpty)
+            .define_method("local_file?", &QUrl::isLocalFile)
+            .define_method("parent_of?", &QUrl::isParentOf, Arg("url"))
+            .define_method("relative?", &QUrl::isRelative)
+            .define_method("valid?", &QUrl::isValid)
+            .define_method("matches", &QUrl::matches, Arg("url"), Arg("options"))
+            .define_method("password", &QUrl::password, Arg("options") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::ComponentFormattingOption::FullyDecoded))
+            .define_method("path", &QUrl::path, Arg("options") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::ComponentFormattingOption::FullyDecoded))
+            .define_method("port", &QUrl::port, Arg("default_port") = static_cast<int>(-1))
+            .define_method("query", &QUrl::query, Arg("options") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::ComponentFormattingOption::PrettyDecoded))
+            .define_method("resolved", &QUrl::resolved, Arg("relative"))
+            .define_method("scheme", &QUrl::scheme)
+            .define_method("set_authority", &QUrl::setAuthority, Arg("authority"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::TolerantMode))
+            .define_method("set_fragment", &QUrl::setFragment, Arg("fragment"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::TolerantMode))
+            .define_method("set_host", &QUrl::setHost, Arg("host"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::DecodedMode))
+            .define_method("set_password", &QUrl::setPassword, Arg("password"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::DecodedMode))
+            .define_method("set_path", &QUrl::setPath, Arg("path"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::DecodedMode))
+            .define_method("set_port", &QUrl::setPort, Arg("port"))
+            .define_method<void (QUrl::*)(const QString &, QUrl::ParsingMode)>("set_query", &QUrl::setQuery, Arg("query"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::TolerantMode))
+            .define_method<void (QUrl::*)(const QUrlQuery &)>("set_query", &QUrl::setQuery, Arg("query"))
+            .define_method("set_scheme", &QUrl::setScheme, Arg("scheme"))
+            .define_method("set_url", &QUrl::setUrl, Arg("url"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::TolerantMode))
+            .define_method("set_user_info", &QUrl::setUserInfo, Arg("user_info"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::TolerantMode))
+            .define_method("set_user_name", &QUrl::setUserName, Arg("user_name"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::DecodedMode))
+            .define_method("to_display_string", &QUrl::toDisplayString, Arg("options") = static_cast<QUrl::FormattingOptions>(QUrl::ComponentFormattingOption::PrettyDecoded))
+            .define_method("to_encoded", &QUrl::toEncoded, Arg("options") = static_cast<QUrl::FormattingOptions>(QUrl::ComponentFormattingOption::PrettyDecoded))
+            .define_method("to_local_file", &QUrl::toLocalFile)
+            .define_method("to_string", &QUrl::toString, Arg("options") = static_cast<QUrl::FormattingOptions>(QUrl::ComponentFormattingOption::PrettyDecoded))
+            .define_method("url", &QUrl::url, Arg("options") = static_cast<QUrl::FormattingOptions>(QUrl::ComponentFormattingOption::PrettyDecoded))
+            .define_method("user_info", &QUrl::userInfo, Arg("options") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::ComponentFormattingOption::PrettyDecoded))
+            .define_method("user_name", &QUrl::userName, Arg("options") = static_cast<QUrl::ComponentFormattingOptions>(QUrl::ComponentFormattingOption::FullyDecoded))
+            // Static Public Members
+            .define_singleton_function("from_ace", &QUrl::fromAce, Arg("domain"), Arg("options") = static_cast<QUrl::AceProcessingOptions>(QUrl::AceProcessingOptions {}))
+            .define_singleton_function("from_encoded", &QUrl::fromEncoded, Arg("input"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::TolerantMode))
+            .define_singleton_function("from_local_file", &QUrl::fromLocalFile, Arg("localfile"))
+            .define_singleton_function("from_percent_encoding", &QUrl::fromPercentEncoding, Arg("input"))
+            .define_singleton_function("from_string_list", &QUrl::fromStringList, Arg("uris"), Arg("mode") = static_cast<QUrl::ParsingMode>(QUrl::ParsingMode::TolerantMode))
+            .define_singleton_function("from_user_input", &QUrl::fromUserInput, Arg("user_input"), Arg("working_directory") = static_cast<const QString &>(QString()), Arg("options") = static_cast<QUrl::UserInputResolutionOptions>(QUrl::UserInputResolutionOption::DefaultResolution))
+            .define_singleton_function("idn_whitelist", &QUrl::idnWhitelist)
+            .define_singleton_function("set_idn_whitelist", &QUrl::setIdnWhitelist, Arg("list"))
+            .define_singleton_function("to_ace", &QUrl::toAce, Arg("domain"), Arg("options") = static_cast<QUrl::AceProcessingOptions>(QUrl::AceProcessingOptions {}))
+            .define_singleton_function("to_percent_encoding", &QUrl::toPercentEncoding, Arg("input"), Arg("exclude") = static_cast<const QByteArray &>(QByteArray()), Arg("include") = static_cast<const QByteArray &>(QByteArray()))
+            .define_singleton_function("to_string_list", &QUrl::toStringList, Arg("uris"), Arg("options") = static_cast<QUrl::FormattingOptions>(QUrl::ComponentFormattingOption::PrettyDecoded));
+
+    Data_Type<QUrl::AceProcessingOption> rb_cQUrlAceProcessingOption =
+        // RubyQt6::QtCore::QUrl::AceProcessingOption
+        define_qenum_under<QUrl::AceProcessingOption>(rb_cQUrl, "AceProcessingOption");
+        define_qenum_value_under(rb_cQUrlAceProcessingOption, "IgnoreIDNWhitelist", QUrl::AceProcessingOption::IgnoreIDNWhitelist);
+        define_qenum_value_under(rb_cQUrlAceProcessingOption, "AceTransitionalProcessing", QUrl::AceProcessingOption::AceTransitionalProcessing);
+
+    Data_Type<QUrl::ComponentFormattingOption> rb_cQUrlComponentFormattingOption =
+        // RubyQt6::QtCore::QUrl::ComponentFormattingOption
+        define_qenum_under<QUrl::ComponentFormattingOption>(rb_cQUrl, "ComponentFormattingOption");
+        define_qenum_value_under(rb_cQUrlComponentFormattingOption, "PrettyDecoded", QUrl::ComponentFormattingOption::PrettyDecoded);
+        define_qenum_value_under(rb_cQUrlComponentFormattingOption, "EncodeSpaces", QUrl::ComponentFormattingOption::EncodeSpaces);
+        define_qenum_value_under(rb_cQUrlComponentFormattingOption, "EncodeUnicode", QUrl::ComponentFormattingOption::EncodeUnicode);
+        define_qenum_value_under(rb_cQUrlComponentFormattingOption, "EncodeDelimiters", QUrl::ComponentFormattingOption::EncodeDelimiters);
+        define_qenum_value_under(rb_cQUrlComponentFormattingOption, "EncodeReserved", QUrl::ComponentFormattingOption::EncodeReserved);
+        define_qenum_value_under(rb_cQUrlComponentFormattingOption, "DecodeReserved", QUrl::ComponentFormattingOption::DecodeReserved);
+        define_qenum_value_under(rb_cQUrlComponentFormattingOption, "FullyEncoded", QUrl::ComponentFormattingOption::FullyEncoded);
+        define_qenum_value_under(rb_cQUrlComponentFormattingOption, "FullyDecoded", QUrl::ComponentFormattingOption::FullyDecoded);
+
+    Data_Type<QUrl::ParsingMode> rb_cQUrlParsingMode =
+        // RubyQt6::QtCore::QUrl::ParsingMode
+        define_qenum_under<QUrl::ParsingMode>(rb_cQUrl, "ParsingMode");
+        define_qenum_value_under(rb_cQUrlParsingMode, "TolerantMode", QUrl::ParsingMode::TolerantMode);
+        define_qenum_value_under(rb_cQUrlParsingMode, "StrictMode", QUrl::ParsingMode::StrictMode);
+        define_qenum_value_under(rb_cQUrlParsingMode, "DecodedMode", QUrl::ParsingMode::DecodedMode);
+
+    Data_Type<QUrl::UrlFormattingOption> rb_cQUrlUrlFormattingOption =
+        // RubyQt6::QtCore::QUrl::UrlFormattingOption
+        define_qenum_under<QUrl::UrlFormattingOption>(rb_cQUrl, "UrlFormattingOption");
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "None", QUrl::UrlFormattingOption::None);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "RemoveScheme", QUrl::UrlFormattingOption::RemoveScheme);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "RemovePassword", QUrl::UrlFormattingOption::RemovePassword);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "RemoveUserInfo", QUrl::UrlFormattingOption::RemoveUserInfo);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "RemovePort", QUrl::UrlFormattingOption::RemovePort);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "RemoveAuthority", QUrl::UrlFormattingOption::RemoveAuthority);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "RemovePath", QUrl::UrlFormattingOption::RemovePath);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "RemoveQuery", QUrl::UrlFormattingOption::RemoveQuery);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "RemoveFragment", QUrl::UrlFormattingOption::RemoveFragment);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "PreferLocalFile", QUrl::UrlFormattingOption::PreferLocalFile);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "StripTrailingSlash", QUrl::UrlFormattingOption::StripTrailingSlash);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "RemoveFilename", QUrl::UrlFormattingOption::RemoveFilename);
+        define_qenum_value_under(rb_cQUrlUrlFormattingOption, "NormalizePathSegments", QUrl::UrlFormattingOption::NormalizePathSegments);
+
+    Data_Type<QUrl::UserInputResolutionOption> rb_cQUrlUserInputResolutionOption =
+        // RubyQt6::QtCore::QUrl::UserInputResolutionOption
+        define_qenum_under<QUrl::UserInputResolutionOption>(rb_cQUrl, "UserInputResolutionOption");
+        define_qenum_value_under(rb_cQUrlUserInputResolutionOption, "DefaultResolution", QUrl::UserInputResolutionOption::DefaultResolution);
+        define_qenum_value_under(rb_cQUrlUserInputResolutionOption, "AssumeLocalFile", QUrl::UserInputResolutionOption::AssumeLocalFile);
+
+    Data_Type<QFlags<QUrl::AceProcessingOption>> rb_cQUrlAceProcessingOptions =
+        // RubyQt6::QtCore::QUrl::AceProcessingOptions
+        define_qflags_under<QUrl::AceProcessingOption>(rb_cQUrl, "AceProcessingOptions");
+
+    Data_Type<QFlags<QUrl::ComponentFormattingOption>> rb_cQUrlComponentFormattingOptions =
+        // RubyQt6::QtCore::QUrl::ComponentFormattingOptions
+        define_qflags_under<QUrl::ComponentFormattingOption>(rb_cQUrl, "ComponentFormattingOptions");
+
+    Data_Type<QFlags<QUrl::UrlFormattingOption>> rb_cQUrlFormattingOptions =
+        // RubyQt6::QtCore::QUrl::FormattingOptions
+        define_qflags_under<QUrl::UrlFormattingOption>(rb_cQUrl, "FormattingOptions");
+
+    Data_Type<QFlags<QUrl::UserInputResolutionOption>> rb_cQUrlUserInputResolutionOptions =
+        // RubyQt6::QtCore::QUrl::UserInputResolutionOptions
+        define_qflags_under<QUrl::UserInputResolutionOption>(rb_cQUrl, "UserInputResolutionOptions");
+}

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

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qurl(Rice::Module rb_mQt6QtCore);