ruby-qt6-qtcore 1.0.0

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

@@ -0,0 +1,80 @@
+#include "qobject-rb.hpp"
+#include <qobject.h>
+
+#include <QBindable>
+#include <QEvent>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QThread>
+#include <QVariant>
+
+using namespace Rice;
+
+Rice::Class rb_cQObject;
+
+int QObject_emit(QObject *sender, const QMetaMethod *signal, const std::vector<QVariant> &args)
+{
+    Q_ASSERT(signal->isValid());
+    Q_ASSERT(signal->methodType() == QMetaMethod::Signal);
+
+    std::vector<void *> arguments(args.size() + 1, nullptr);
+    for (size_t i = 0; i < args.size(); ++i)
+        arguments[i + 1] = const_cast<void *>(args[i].constData());
+    QMetaObject::activate(sender, signal->methodIndex(), arguments.data());
+
+    return -1;
+}
+
+void Init_qobject(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQObject =
+        // RubyQt6::QtCore::QObject
+        define_class_under<QObject>(rb_mQt6QtCore, "QObject")
+            // RubyQt6-Defined Functions
+            .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("_take_ownership_from_ruby", [](QObject *) -> void {}, Arg("object").takeOwnership())
+            // Constructor
+            .define_constructor(Constructor<QObject, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("bindable_object_name", &QObject::bindableObjectName)
+            .define_method<QBindingStorage *(QObject::*)()>("binding_storage", &QObject::bindingStorage)
+            .define_method<const QBindingStorage *(QObject::*)() const>("binding_storage", &QObject::bindingStorage)
+            .define_method("block_signals", &QObject::blockSignals, Arg("b"))
+            .define_method("_children", &QObject::children)
+            .define_method("dump_object_info", &QObject::dumpObjectInfo)
+            .define_method("dump_object_tree", &QObject::dumpObjectTree)
+            .define_method("dynamic_property_names", &QObject::dynamicPropertyNames)
+            .define_method<QObject *(QObject::*)(QAnyStringView, Qt::FindChildOptions) const>("_find_child", &QObject::findChild, Arg("name"), Arg("options"))
+            .define_method<QList<QObject *> (QObject::*)(QAnyStringView, Qt::FindChildOptions) const>("_find_children", &QObject::findChildren, Arg("name"), Arg("options"))
+            .define_method("inherits", &QObject::inherits, Arg("classname"))
+            .define_method("install_event_filter", &QObject::installEventFilter, Arg("filter_obj"))
+            .define_method("quick_item_type?", &QObject::isQuickItemType)
+            .define_method("widget_type?", &QObject::isWidgetType)
+            .define_method("window_type?", &QObject::isWindowType)
+            .define_method<void (QObject::*)(Qt::TimerId)>("kill_timer", &QObject::killTimer, Arg("id"))
+            .define_method<void (QObject::*)(int)>("kill_timer", &QObject::killTimer, Arg("id"))
+            .define_method("move_to_thread", &QObject::moveToThread, Arg("thread"))
+            .define_method("object_name", &QObject::objectName)
+            .define_method("_parent", &QObject::parent)
+            .define_method("property", &QObject::property, Arg("name"))
+            .define_method("remove_event_filter", &QObject::removeEventFilter, Arg("obj"))
+            .define_method<void (QObject::*)(const QString &)>("set_object_name", &QObject::setObjectName, Arg("name"))
+            .define_method("set_parent", &QObject::setParent, Arg("parent"))
+            .define_method<bool (QObject::*)(const char *, QVariant &&)>("set_property", &QObject::setProperty, Arg("name"), Arg("value"))
+            .define_method<bool (QObject::*)(const char *, const QVariant &)>("set_property", &QObject::setProperty, Arg("name"), Arg("value"))
+            .define_method("signals_blocked", &QObject::signalsBlocked)
+            .define_method<int (QObject::*)(int, Qt::TimerType)>("start_timer", &QObject::startTimer, Arg("interval"), Arg("timer_type") = static_cast<Qt::TimerType>(Qt::CoarseTimer))
+            .define_method<int (QObject::*)(std::chrono::nanoseconds, Qt::TimerType)>("start_timer", &QObject::startTimer, Arg("time"), Arg("timer_type") = static_cast<Qt::TimerType>(Qt::CoarseTimer))
+            .define_method("thread", &QObject::thread)
+            // Public Slots
+            .define_method("delete_later", &QObject::deleteLater)
+            // Signals
+            .define_method("destroyed", &QObject::destroyed, Arg("obj") = static_cast<QObject *>(nullptr))
+            .define_method("object_name_changed", &QObject::objectNameChanged, Arg("object_name"))
+            // Static Public Members
+            .define_singleton_function<QMetaObject::Connection (*)(const QObject *, const char *, const QObject *, const char *, Qt::ConnectionType)>("_connect", &QObject::connect, Arg("sender"), Arg("signal"), Arg("receiver"), Arg("member"), Arg("type") = static_cast<Qt::ConnectionType>(Qt::AutoConnection))
+            .define_singleton_function<bool (*)(const QObject *, const char *, const QObject *, const char *)>("_disconnect", &QObject::disconnect, Arg("sender"), Arg("signal"), Arg("receiver"), Arg("member"))
+            .define_singleton_function<bool (*)(const QMetaObject::Connection &)>("_disconnect", &QObject::disconnect, Arg("conn"))
+            .define_singleton_function("tr", &QObject::tr, Arg("source_text"), Arg("disambiguation") = static_cast<const char *>(nullptr), Arg("n") = static_cast<int>(-1));
+}

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

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

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

@@ -0,0 +1,65 @@
+#include "qpoint-rb.hpp"
+#include <qpoint.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQPoint;
+Rice::Class rb_cQPointF;
+
+void Init_qpoint(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQPoint =
+        // RubyQt6::QtCore::QPoint
+        define_class_under<QPoint>(rb_mQt6QtCore, "QPoint")
+            // RubyQt6-Defined Functions
+            .define_method("*", [](QPoint *self,  qreal  factor) -> QPoint { return *self *  factor; })
+            .define_method("+", [](QPoint *self, QPoint  *other) -> QPoint { return *self +  *other; })
+            .define_method("-", [](QPoint *self, QPoint  *other) -> QPoint { return *self -  *other; })
+            .define_method("/", [](QPoint *self,  qreal divisor) -> QPoint { return *self / divisor; })
+            .define_method("+@", [](QPoint *self) -> QPoint { return + *self; })
+            .define_method("-@", [](QPoint *self) -> QPoint { return - *self; })
+            .define_singleton_function("_operator_equal", [](QPoint *lhs, QPoint  *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
+            .define_singleton_function("_operator_equal", [](QPoint *lhs, QPointF *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
+            // Constructor
+            .define_constructor(Constructor<QPoint>())
+            .define_constructor(Constructor<QPoint, int, int>(), Arg("xpos"), Arg("ypos"))
+            // Public Functions
+            .define_method("null?", &QPoint::isNull)
+            .define_method("manhattan_length", &QPoint::manhattanLength)
+            .define_method("rx", &QPoint::rx)
+            .define_method("ry", &QPoint::ry)
+            .define_method("set_x", &QPoint::setX)
+            .define_method("set_y", &QPoint::setY)
+            .define_method("to_point_f", &QPoint::toPointF)
+            .define_method("transposed", &QPoint::transposed)
+            .define_method("x", &QPoint::x)
+            .define_method("y", &QPoint::y);
+
+    rb_cQPointF =
+        // RubyQt6::QtCore::QPointF
+        define_class_under<QPointF>(rb_mQt6QtCore, "QPointF")
+            // RubyQt6-Defined Functions
+            .define_method("*", [](QPointF *self,   qreal  factor) -> QPointF { return *self *  factor; })
+            .define_method("+", [](QPointF *self, QPointF  *other) -> QPointF { return *self +  *other; })
+            .define_method("-", [](QPointF *self, QPointF  *other) -> QPointF { return *self -  *other; })
+            .define_method("/", [](QPointF *self,   qreal divisor) -> QPointF { return *self / divisor; })
+            .define_method("+@", [](QPointF *self) -> QPointF { return + *self; })
+            .define_method("-@", [](QPointF *self) -> QPointF { return - *self; })
+            .define_singleton_function("_operator_equal", [](QPointF *lhs, QPoint  *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
+            .define_singleton_function("_operator_equal", [](QPointF *lhs, QPointF *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
+            // Constructor
+            .define_constructor(Constructor<QPointF>())
+            .define_constructor(Constructor<QPointF, qreal, qreal>(), Arg("xpos"), Arg("ypos"))
+            .define_constructor(Constructor<QPointF, const QPoint &>(), Arg("point"))
+            // Public Functions
+            .define_method("null?", &QPointF::isNull)
+            .define_method("manhattan_length", &QPointF::manhattanLength)
+            .define_method("rx", &QPointF::rx)
+            .define_method("ry", &QPointF::ry)
+            .define_method("set_x", &QPointF::setX)
+            .define_method("set_y", &QPointF::setY)
+            .define_method("to_point", &QPointF::toPoint)
+            .define_method("transposed", &QPointF::transposed)
+            .define_method("x", &QPointF::x)
+            .define_method("y", &QPointF::y);
+}

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

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

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

@@ -0,0 +1,162 @@
+#include "qrect-rb.hpp"
+#include <qrect.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQRect;
+Rice::Class rb_cQRectF;
+
+void Init_qrect(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQRect =
+        // RubyQt6::QtCore::QRect
+        define_class_under<QRect>(rb_mQt6QtCore, "QRect")
+            // RubyQt6-Defined Functions
+            .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
+            .define_constructor(Constructor<QRect>())
+            .define_constructor(Constructor<QRect, int, int, int, int>(), Arg("x"), Arg("y"), Arg("width"), Arg("height"))
+            .define_constructor(Constructor<QRect, const QPoint &, const QPoint &>(), Arg("top_left"), Arg("bottom_right"))
+            .define_constructor(Constructor<QRect, const QPoint &, const QSize &>(), Arg("top_left"), Arg("size"))
+            // Public Functions
+            .define_method("adjust", &QRect::adjust, Arg("dx1"), Arg("dy1"), Arg("dx2"), Arg("dy2"))
+            .define_method("adjusted", &QRect::adjusted, Arg("dx1"), Arg("dy1"), Arg("dx2"), Arg("dy2"))
+            .define_method("bottom", &QRect::bottom)
+            .define_method("bottom_left", &QRect::bottomLeft)
+            .define_method("bottom_right", &QRect::bottomRight)
+            .define_method("center", &QRect::center)
+            .define_method<bool (QRect::*)(const QPoint &, bool) const noexcept>("contains", &QRect::contains, Arg("p"), Arg("proper") = false)
+            .define_method<bool (QRect::*)(const QRect &, bool) const noexcept>("contains", &QRect::contains, Arg("r"), Arg("proper") = false)
+            .define_method<bool (QRect::*)(int, int) const noexcept>("contains", &QRect::contains, Arg("x"), Arg("y"))
+            .define_method<bool (QRect::*)(int, int, bool) const noexcept>("contains", &QRect::contains, Arg("x"), Arg("y"), Arg("proper"))
+            .define_method("get_coords", &QRect::getCoords, Arg("x1"), Arg("y1"), Arg("x2"), Arg("y2"))
+            .define_method("get_rect", &QRect::getRect, Arg("x"), Arg("y"), Arg("width"), Arg("height"))
+            .define_method("height", &QRect::height)
+            .define_method("intersected", &QRect::intersected, Arg("other"))
+            .define_method("intersects", &QRect::intersects, Arg("r"))
+            .define_method("empty?", &QRect::isEmpty)
+            .define_method("null?", &QRect::isNull)
+            .define_method("valid?", &QRect::isValid)
+            .define_method("left", &QRect::left)
+            .define_method("margins_added", &QRect::marginsAdded, Arg("margins"))
+            .define_method("margins_removed", &QRect::marginsRemoved, Arg("margins"))
+            .define_method("move_bottom", &QRect::moveBottom, Arg("y"))
+            .define_method("move_bottom_left", &QRect::moveBottomLeft, Arg("position"))
+            .define_method("move_bottom_right", &QRect::moveBottomRight, Arg("position"))
+            .define_method("move_center", &QRect::moveCenter, Arg("position"))
+            .define_method("move_left", &QRect::moveLeft, Arg("x"))
+            .define_method("move_right", &QRect::moveRight, Arg("x"))
+            .define_method<void (QRect::*)(const QPoint &)>("move_to", &QRect::moveTo, Arg("position"))
+            .define_method<void (QRect::*)(int, int)>("move_to", &QRect::moveTo, Arg("x"), Arg("y"))
+            .define_method("move_top", &QRect::moveTop, Arg("y"))
+            .define_method("move_top_left", &QRect::moveTopLeft, Arg("position"))
+            .define_method("move_top_right", &QRect::moveTopRight, Arg("position"))
+            .define_method("normalized", &QRect::normalized)
+            .define_method("right", &QRect::right)
+            .define_method("set_bottom", &QRect::setBottom, Arg("y"))
+            .define_method("set_bottom_left", &QRect::setBottomLeft, Arg("position"))
+            .define_method("set_bottom_right", &QRect::setBottomRight, Arg("position"))
+            .define_method("set_coords", &QRect::setCoords, Arg("x1"), Arg("y1"), Arg("x2"), Arg("y2"))
+            .define_method("set_height", &QRect::setHeight, Arg("height"))
+            .define_method("set_left", &QRect::setLeft, Arg("x"))
+            .define_method("set_rect", &QRect::setRect, Arg("x"), Arg("y"), Arg("width"), Arg("height"))
+            .define_method("set_right", &QRect::setRight, Arg("x"))
+            .define_method("set_size", &QRect::setSize, Arg("size"))
+            .define_method("set_top", &QRect::setTop, Arg("y"))
+            .define_method("set_top_left", &QRect::setTopLeft, Arg("position"))
+            .define_method("set_top_right", &QRect::setTopRight, Arg("position"))
+            .define_method("set_width", &QRect::setWidth, Arg("width"))
+            .define_method("set_x", &QRect::setX, Arg("x"))
+            .define_method("set_y", &QRect::setY, Arg("y"))
+            .define_method("size", &QRect::size)
+            .define_method("to_rect_f", &QRect::toRectF)
+            .define_method("top", &QRect::top)
+            .define_method("top_left", &QRect::topLeft)
+            .define_method("top_right", &QRect::topRight)
+            .define_method<void (QRect::*)(const QPoint &)>("translate", &QRect::translate, Arg("offset"))
+            .define_method<void (QRect::*)(int, int)>("translate", &QRect::translate, Arg("dx"), Arg("dy"))
+            .define_method<QRect (QRect::*)(const QPoint &) const>("translated", &QRect::translated, Arg("offset"))
+            .define_method<QRect (QRect::*)(int, int) const>("translated", &QRect::translated, Arg("dx"), Arg("dy"))
+            .define_method("transposed", &QRect::transposed)
+            .define_method("united", &QRect::united, Arg("other"))
+            .define_method("width", &QRect::width)
+            .define_method("x", &QRect::x)
+            .define_method("y", &QRect::y);
+
+    rb_cQRectF =
+        // RubyQt6::QtCore::QRectF
+        define_class_under<QRectF>(rb_mQt6QtCore, "QRectF")
+            // RubyQt6-Defined Functions
+            .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
+            .define_constructor(Constructor<QRectF>())
+            .define_constructor(Constructor<QRectF, qreal, qreal, qreal, qreal>(), Arg("x"), Arg("y"), Arg("width"), Arg("height"))
+            .define_constructor(Constructor<QRectF, const QPointF &, const QPointF &>(), Arg("top_left"), Arg("bottom_right"))
+            .define_constructor(Constructor<QRectF, const QPointF &, const QSizeF &>(), Arg("top_left"), Arg("size"))
+            .define_constructor(Constructor<QRectF, const QRect &>(), Arg("rect"))
+            // Public Functions
+            .define_method("adjust", &QRectF::adjust, Arg("dx1"), Arg("dy1"), Arg("dx2"), Arg("dy2"))
+            .define_method("adjusted", &QRectF::adjusted, Arg("dx1"), Arg("dy1"), Arg("dx2"), Arg("dy2"))
+            .define_method("bottom", &QRectF::bottom)
+            .define_method("bottom_left", &QRectF::bottomLeft)
+            .define_method("bottom_right", &QRectF::bottomRight)
+            .define_method("center", &QRectF::center)
+            .define_method<bool (QRectF::*)(const QPointF &) const noexcept>("contains", &QRectF::contains, Arg("p"))
+            .define_method<bool (QRectF::*)(const QRectF &) const noexcept>("contains", &QRectF::contains, Arg("r"))
+            .define_method<bool (QRectF::*)(qreal, qreal) const noexcept>("contains", &QRectF::contains, Arg("x"), Arg("y"))
+            .define_method("get_coords", &QRectF::getCoords, Arg("x1"), Arg("y1"), Arg("x2"), Arg("y2"))
+            .define_method("get_rect", &QRectF::getRect, Arg("x"), Arg("y"), Arg("width"), Arg("height"))
+            .define_method("height", &QRectF::height)
+            .define_method("intersected", &QRectF::intersected, Arg("other"))
+            .define_method("intersects", &QRectF::intersects, Arg("r"))
+            .define_method("empty?", &QRectF::isEmpty)
+            .define_method("null?", &QRectF::isNull)
+            .define_method("valid?", &QRectF::isValid)
+            .define_method("left", &QRectF::left)
+            .define_method("margins_added", &QRectF::marginsAdded, Arg("margins"))
+            .define_method("margins_removed", &QRectF::marginsRemoved, Arg("margins"))
+            .define_method("move_bottom", &QRectF::moveBottom, Arg("y"))
+            .define_method("move_bottom_left", &QRectF::moveBottomLeft, Arg("position"))
+            .define_method("move_bottom_right", &QRectF::moveBottomRight, Arg("position"))
+            .define_method("move_center", &QRectF::moveCenter, Arg("position"))
+            .define_method("move_left", &QRectF::moveLeft, Arg("x"))
+            .define_method("move_right", &QRectF::moveRight, Arg("x"))
+            .define_method<void (QRectF::*)(const QPointF &)>("move_to", &QRectF::moveTo, Arg("position"))
+            .define_method<void (QRectF::*)(qreal, qreal)>("move_to", &QRectF::moveTo, Arg("x"), Arg("y"))
+            .define_method("move_top", &QRectF::moveTop, Arg("y"))
+            .define_method("move_top_left", &QRectF::moveTopLeft, Arg("position"))
+            .define_method("move_top_right", &QRectF::moveTopRight, Arg("position"))
+            .define_method("normalized", &QRectF::normalized)
+            .define_method("right", &QRectF::right)
+            .define_method("set_bottom", &QRectF::setBottom, Arg("y"))
+            .define_method("set_bottom_left", &QRectF::setBottomLeft, Arg("position"))
+            .define_method("set_bottom_right", &QRectF::setBottomRight, Arg("position"))
+            .define_method("set_coords", &QRectF::setCoords, Arg("x1"), Arg("y1"), Arg("x2"), Arg("y2"))
+            .define_method("set_height", &QRectF::setHeight, Arg("height"))
+            .define_method("set_left", &QRectF::setLeft, Arg("x"))
+            .define_method("set_rect", &QRectF::setRect, Arg("x"), Arg("y"), Arg("width"), Arg("height"))
+            .define_method("set_right", &QRectF::setRight, Arg("x"))
+            .define_method("set_size", &QRectF::setSize, Arg("size"))
+            .define_method("set_top", &QRectF::setTop, Arg("y"))
+            .define_method("set_top_left", &QRectF::setTopLeft, Arg("position"))
+            .define_method("set_top_right", &QRectF::setTopRight, Arg("position"))
+            .define_method("set_width", &QRectF::setWidth, Arg("width"))
+            .define_method("set_x", &QRectF::setX, Arg("x"))
+            .define_method("set_y", &QRectF::setY, Arg("y"))
+            .define_method("size", &QRectF::size)
+            .define_method("to_rect", &QRectF::toRect)
+            .define_method("top", &QRectF::top)
+            .define_method("top_left", &QRectF::topLeft)
+            .define_method("top_right", &QRectF::topRight)
+            .define_method<void (QRectF::*)(const QPointF &)>("translate", &QRectF::translate, Arg("offset"))
+            .define_method<void (QRectF::*)(qreal, qreal)>("translate", &QRectF::translate, Arg("dx"), Arg("dy"))
+            .define_method<QRectF (QRectF::*)(const QPointF &) const>("translated", &QRectF::translated, Arg("offset"))
+            .define_method<QRectF (QRectF::*)(qreal, qreal) const>("translated", &QRectF::translated, Arg("dx"), Arg("dy"))
+            .define_method("transposed", &QRectF::transposed)
+            .define_method("united", &QRectF::united, Arg("other"))
+            .define_method("width", &QRectF::width)
+            .define_method("x", &QRectF::x)
+            .define_method("y", &QRectF::y);
+}

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

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

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

@@ -0,0 +1,114 @@
+#include "qregularexpression-rb.hpp"
+#include <qregularexpression.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQRegularExpression;
+Rice::Class rb_cQRegularExpressionMatch;
+
+void Init_qregularexpression(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQRegularExpression =
+        // RubyQt6::QtCore::QRegularExpression
+        define_class_under<QRegularExpression>(rb_mQt6QtCore, "QRegularExpression")
+            // Constructor
+            .define_constructor(Constructor<QRegularExpression, const QString &, QRegularExpression::PatternOptions>(), Arg("pattern"), Arg("options"))
+            // Public Functions
+            .define_method("capture_count", &QRegularExpression::captureCount)
+            .define_method("error_string", &QRegularExpression::errorString)
+            .define_method<QRegularExpressionMatchIterator (QRegularExpression::*)(const QString &, qsizetype, QRegularExpression::MatchType, QRegularExpression::MatchOptions) const>("global_match", &QRegularExpression::globalMatch, Arg("subject"), Arg("offset") = static_cast<qsizetype>(0), Arg("match_type") = static_cast<QRegularExpression::MatchType>(QRegularExpression::MatchType::NormalMatch), Arg("match_options") = static_cast<QRegularExpression::MatchOptions>(QRegularExpression::MatchOption::NoMatchOption))
+            .define_method("global_match_view", &QRegularExpression::globalMatchView, Arg("subject_view"), Arg("offset") = static_cast<qsizetype>(0), Arg("match_type") = static_cast<QRegularExpression::MatchType>(QRegularExpression::MatchType::NormalMatch), Arg("match_options") = static_cast<QRegularExpression::MatchOptions>(QRegularExpression::MatchOption::NoMatchOption))
+            .define_method("valid?", &QRegularExpression::isValid)
+            .define_method<QRegularExpressionMatch (QRegularExpression::*)(const QString &, qsizetype, QRegularExpression::MatchType, QRegularExpression::MatchOptions) const>("match", &QRegularExpression::match, Arg("subject"), Arg("offset") = static_cast<qsizetype>(0), Arg("match_type") = static_cast<QRegularExpression::MatchType>(QRegularExpression::MatchType::NormalMatch), Arg("match_options") = static_cast<QRegularExpression::MatchOptions>(QRegularExpression::MatchOption::NoMatchOption))
+            .define_method("match_view", &QRegularExpression::matchView, Arg("subject_view"), Arg("offset") = static_cast<qsizetype>(0), Arg("match_type") = static_cast<QRegularExpression::MatchType>(QRegularExpression::MatchType::NormalMatch), Arg("match_options") = static_cast<QRegularExpression::MatchOptions>(QRegularExpression::MatchOption::NoMatchOption))
+            .define_method("named_capture_groups", &QRegularExpression::namedCaptureGroups)
+            .define_method("optimize", &QRegularExpression::optimize)
+            .define_method("pattern", &QRegularExpression::pattern)
+            .define_method("pattern_error_offset", &QRegularExpression::patternErrorOffset)
+            .define_method("pattern_options", &QRegularExpression::patternOptions)
+            .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));
+
+    Data_Type<QRegularExpression::PatternOption> rb_cQRegularExpressionPatternOption =
+        // RubyQt6::QtCore::QRegularExpression::PatternOption
+        define_qenum_under<QRegularExpression::PatternOption>(rb_cQRegularExpression, "PatternOption");
+        define_qenum_value_under(rb_cQRegularExpressionPatternOption, "NoPatternOption", QRegularExpression::PatternOption::NoPatternOption);
+        define_qenum_value_under(rb_cQRegularExpressionPatternOption, "CaseInsensitiveOption", QRegularExpression::PatternOption::CaseInsensitiveOption);
+        define_qenum_value_under(rb_cQRegularExpressionPatternOption, "DotMatchesEverythingOption", QRegularExpression::PatternOption::DotMatchesEverythingOption);
+        define_qenum_value_under(rb_cQRegularExpressionPatternOption, "MultilineOption", QRegularExpression::PatternOption::MultilineOption);
+        define_qenum_value_under(rb_cQRegularExpressionPatternOption, "ExtendedPatternSyntaxOption", QRegularExpression::PatternOption::ExtendedPatternSyntaxOption);
+        define_qenum_value_under(rb_cQRegularExpressionPatternOption, "InvertedGreedinessOption", QRegularExpression::PatternOption::InvertedGreedinessOption);
+        define_qenum_value_under(rb_cQRegularExpressionPatternOption, "DontCaptureOption", QRegularExpression::PatternOption::DontCaptureOption);
+        define_qenum_value_under(rb_cQRegularExpressionPatternOption, "UseUnicodePropertiesOption", QRegularExpression::PatternOption::UseUnicodePropertiesOption);
+
+    Data_Type<QRegularExpression::MatchType> rb_cQRegularExpressionMatchType =
+        // RubyQt6::QtCore::QRegularExpression::MatchType
+        define_qenum_under<QRegularExpression::MatchType>(rb_cQRegularExpression, "MatchType");
+        define_qenum_value_under(rb_cQRegularExpressionMatchType, "NormalMatch", QRegularExpression::MatchType::NormalMatch);
+        define_qenum_value_under(rb_cQRegularExpressionMatchType, "PartialPreferCompleteMatch", QRegularExpression::MatchType::PartialPreferCompleteMatch);
+        define_qenum_value_under(rb_cQRegularExpressionMatchType, "PartialPreferFirstMatch", QRegularExpression::MatchType::PartialPreferFirstMatch);
+        define_qenum_value_under(rb_cQRegularExpressionMatchType, "NoMatch", QRegularExpression::MatchType::NoMatch);
+
+    Data_Type<QRegularExpression::MatchOption> rb_cQRegularExpressionMatchOption =
+        // RubyQt6::QtCore::QRegularExpression::MatchOption
+        define_qenum_under<QRegularExpression::MatchOption>(rb_cQRegularExpression, "MatchOption");
+        define_qenum_value_under(rb_cQRegularExpressionMatchOption, "NoMatchOption", QRegularExpression::MatchOption::NoMatchOption);
+        define_qenum_value_under(rb_cQRegularExpressionMatchOption, "AnchorAtOffsetMatchOption", QRegularExpression::MatchOption::AnchorAtOffsetMatchOption);
+        define_qenum_value_under(rb_cQRegularExpressionMatchOption, "DontCheckSubjectStringMatchOption", QRegularExpression::MatchOption::DontCheckSubjectStringMatchOption);
+
+    Data_Type<QRegularExpression::WildcardConversionOption> rb_cQRegularExpressionWildcardConversionOption =
+        // RubyQt6::QtCore::QRegularExpression::WildcardConversionOption
+        define_qenum_under<QRegularExpression::WildcardConversionOption>(rb_cQRegularExpression, "WildcardConversionOption");
+        define_qenum_value_under(rb_cQRegularExpressionWildcardConversionOption, "DefaultWildcardConversion", QRegularExpression::WildcardConversionOption::DefaultWildcardConversion);
+        define_qenum_value_under(rb_cQRegularExpressionWildcardConversionOption, "UnanchoredWildcardConversion", QRegularExpression::WildcardConversionOption::UnanchoredWildcardConversion);
+        define_qenum_value_under(rb_cQRegularExpressionWildcardConversionOption, "NonPathWildcardConversion", QRegularExpression::WildcardConversionOption::NonPathWildcardConversion);
+
+    Data_Type<QFlags<QRegularExpression::MatchOption>> rb_cQRegularExpressionMatchOptions =
+        // RubyQt6::QtCore::QRegularExpression::MatchOptions
+        define_qflags_under<QRegularExpression::MatchOption>(rb_cQRegularExpression, "MatchOptions");
+
+    Data_Type<QFlags<QRegularExpression::PatternOption>> rb_cQRegularExpressionPatternOptions =
+        // RubyQt6::QtCore::QRegularExpression::PatternOptions
+        define_qflags_under<QRegularExpression::PatternOption>(rb_cQRegularExpression, "PatternOptions");
+
+    Data_Type<QFlags<QRegularExpression::WildcardConversionOption>> rb_cQRegularExpressionWildcardConversionOptions =
+        // RubyQt6::QtCore::QRegularExpression::WildcardConversionOptions
+        define_qflags_under<QRegularExpression::WildcardConversionOption>(rb_cQRegularExpression, "WildcardConversionOptions");
+
+    rb_cQRegularExpressionMatch =
+        // RubyQt6::QtCore::QRegularExpressionMatch
+        define_class_under<QRegularExpressionMatch>(rb_mQt6QtCore, "QRegularExpressionMatch")
+            // Constructor
+            .define_constructor(Constructor<QRegularExpressionMatch>())
+            // Public Functions
+            .define_method<QString (QRegularExpressionMatch::*)(QAnyStringView) const>("captured", &QRegularExpressionMatch::captured, Arg("name"))
+            .define_method<QString (QRegularExpressionMatch::*)(int) const>("captured", &QRegularExpressionMatch::captured, Arg("nth") = static_cast<int>(0))
+            .define_method<qsizetype (QRegularExpressionMatch::*)(QAnyStringView) const>("captured_end", &QRegularExpressionMatch::capturedEnd, Arg("name"))
+            .define_method<qsizetype (QRegularExpressionMatch::*)(int) const>("captured_end", &QRegularExpressionMatch::capturedEnd, Arg("nth") = static_cast<int>(0))
+            .define_method<qsizetype (QRegularExpressionMatch::*)(QAnyStringView) const>("captured_length", &QRegularExpressionMatch::capturedLength, Arg("name"))
+            .define_method<qsizetype (QRegularExpressionMatch::*)(int) const>("captured_length", &QRegularExpressionMatch::capturedLength, Arg("nth") = static_cast<int>(0))
+            .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)
+            .define_method("has_partial_match", &QRegularExpressionMatch::hasPartialMatch)
+            .define_method("valid?", &QRegularExpressionMatch::isValid)
+            .define_method("last_captured_index", &QRegularExpressionMatch::lastCapturedIndex)
+            .define_method("match_options", &QRegularExpressionMatch::matchOptions)
+            .define_method("match_type", &QRegularExpressionMatch::matchType)
+            .define_method("regular_expression", &QRegularExpressionMatch::regularExpression);
+}

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

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

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

@@ -0,0 +1,48 @@
+#include "qresource-rb.hpp"
+#include <qresource.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QDateTime>
+
+using namespace Rice;
+
+Rice::Class rb_cQResource;
+
+void Init_qresource(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQResource =
+        // RubyQt6::QtCore::QResource
+        define_class_under<QResource>(rb_mQt6QtCore, "QResource")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("register_resource", [](const char *rcc_filename, const char *resource_root) -> bool { return QResource::registerResource(QString(rcc_filename), QString(resource_root)); }, Arg("rcc_filename"), Arg("resource_root") = static_cast<const char *>(nullptr))
+            .define_singleton_function("unregister_resource", [](const char *rcc_filename, const char *resource_root) -> bool { return QResource::unregisterResource(QString(rcc_filename), QString(resource_root)); }, Arg("rcc_filename"), Arg("resource_root") = static_cast<const char *>(nullptr))
+            // Constructor
+            .define_constructor(Constructor<QResource>())
+            .define_constructor(Constructor<QResource, const QString &>(), Arg("file"))
+            .define_constructor(Constructor<QResource, const QString &, const QLocale &>(), Arg("file"), Arg("locale"))
+            // Public Functions
+            .define_method("absolute_file_path", &QResource::absoluteFilePath)
+            .define_method("compression_algorithm", &QResource::compressionAlgorithm)
+            .define_method("data", &QResource::data)
+            .define_method("file_name", &QResource::fileName)
+            .define_method("valid?", &QResource::isValid)
+            .define_method("last_modified", &QResource::lastModified)
+            .define_method("locale", &QResource::locale)
+            .define_method("set_file_name", &QResource::setFileName, Arg("file"))
+            .define_method("set_locale", &QResource::setLocale, Arg("locale"))
+            .define_method("size", &QResource::size)
+            .define_method("uncompressed_data", &QResource::uncompressedData)
+            .define_method("uncompressed_size", &QResource::uncompressedSize)
+            // Static Public Members
+            .define_singleton_function<bool (*)(const QString &, const QString &)>("register_resource", &QResource::registerResource, Arg("rcc_filename"), Arg("resource_root") = static_cast<const QString &>(QString()))
+            .define_singleton_function<bool (*)(const uchar *, const QString &)>("register_resource", &QResource::registerResource, Arg("rcc_data"), Arg("resource_root") = static_cast<const QString &>(QString()))
+            .define_singleton_function<bool (*)(const QString &, const QString &)>("unregister_resource", &QResource::unregisterResource, Arg("rcc_filename"), Arg("resource_root") = static_cast<const QString &>(QString()))
+            .define_singleton_function<bool (*)(const uchar *, const QString &)>("unregister_resource", &QResource::unregisterResource, Arg("rcc_data"), Arg("resource_root") = static_cast<const QString &>(QString()));
+
+    Data_Type<QResource::Compression> rb_cQResourceCompression =
+        // RubyQt6::QtCore::QResource::Compression
+        define_qenum_under<QResource::Compression>(rb_cQResource, "Compression");
+        define_qenum_value_under(rb_cQResourceCompression, "NoCompression", QResource::Compression::NoCompression);
+        define_qenum_value_under(rb_cQResourceCompression, "ZlibCompression", QResource::Compression::ZlibCompression);
+        define_qenum_value_under(rb_cQResourceCompression, "ZstdCompression", QResource::Compression::ZstdCompression);
+}

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

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

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

@@ -0,0 +1,72 @@
+#include "qsettings-rb.hpp"
+#include <qsettings.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQSettings;
+
+void Init_qsettings(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQSettings =
+        // RubyQt6::QtCore::QSettings
+        define_class_under<QSettings, QObject>(rb_mQt6QtCore, "QSettings")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QSettings::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QSettings, QSettings::Format, QSettings::Scope, const QString &, const QString &>(), Arg("format"), Arg("scope"), Arg("organization"), Arg("application"))
+            // Public Functions
+            .define_method("all_keys", &QSettings::allKeys)
+            .define_method("application_name", &QSettings::applicationName)
+            .define_method("_begin_group", &QSettings::beginGroup, Arg("prefix"))
+            .define_method("_begin_read_array", &QSettings::beginReadArray, Arg("prefix"))
+            .define_method("_begin_write_array", &QSettings::beginWriteArray, Arg("prefix"), Arg("size") = static_cast<int>(-1))
+            .define_method("child_groups", &QSettings::childGroups)
+            .define_method("child_keys", &QSettings::childKeys)
+            .define_method("clear", &QSettings::clear)
+            .define_method("_contains", &QSettings::contains, Arg("key"))
+            .define_method("end_array", &QSettings::endArray)
+            .define_method("end_group", &QSettings::endGroup)
+            .define_method("fallbacks_enabled", &QSettings::fallbacksEnabled)
+            .define_method("file_name", &QSettings::fileName)
+            .define_method("format", &QSettings::format)
+            .define_method("group", &QSettings::group)
+            .define_method("atomic_sync_required?", &QSettings::isAtomicSyncRequired)
+            .define_method("writable?", &QSettings::isWritable)
+            .define_method("organization_name", &QSettings::organizationName)
+            .define_method("_remove", &QSettings::remove, Arg("key"))
+            .define_method("scope", &QSettings::scope)
+            .define_method("set_array_index", &QSettings::setArrayIndex, Arg("i"))
+            .define_method("set_atomic_sync_required", &QSettings::setAtomicSyncRequired, Arg("enable"))
+            .define_method("set_fallbacks_enabled", &QSettings::setFallbacksEnabled, Arg("b"))
+            .define_method("_set_value", &QSettings::setValue, Arg("key"), Arg("value"))
+            .define_method("status", &QSettings::status)
+            .define_method("sync", &QSettings::sync)
+            .define_method<QVariant (QSettings::*)(QAnyStringView) const>("_value", &QSettings::value, Arg("key"))
+            .define_method<QVariant (QSettings::*)(QAnyStringView, const QVariant &) const>("_value", &QSettings::value, Arg("key"), Arg("default_value"))
+            // Static Public Members
+            .define_singleton_function("default_format", &QSettings::defaultFormat)
+            // .define_singleton_function("register_format", &QSettings::registerFormat, Arg("extension"), Arg("read_func"), Arg("write_func"), Arg("case_sensitivity") = static_cast<Qt::CaseSensitivity>(Qt::CaseSensitive))
+            .define_singleton_function("set_default_format", &QSettings::setDefaultFormat, Arg("format"))
+            .define_singleton_function("set_path", &QSettings::setPath, Arg("format"), Arg("scope"), Arg("path"));
+
+    Data_Type<QSettings::Format> rb_cQSettingsFormat =
+        // RubyQt6::QtCore::QSettings::Format
+        define_qenum_under<QSettings::Format>(rb_cQSettings, "Format");
+        define_qenum_value_under(rb_cQSettingsFormat, "NativeFormat", QSettings::Format::NativeFormat);
+        define_qenum_value_under(rb_cQSettingsFormat, "IniFormat", QSettings::Format::IniFormat);
+        define_qenum_value_under(rb_cQSettingsFormat, "InvalidFormat", QSettings::Format::InvalidFormat);
+
+    Data_Type<QSettings::Scope> rb_cQSettingsScope =
+        // RubyQt6::QtCore::QSettings::Scope
+        define_qenum_under<QSettings::Scope>(rb_cQSettings, "Scope");
+        define_qenum_value_under(rb_cQSettingsScope, "UserScope", QSettings::Scope::UserScope);
+        define_qenum_value_under(rb_cQSettingsScope, "SystemScope", QSettings::Scope::SystemScope);
+
+    Data_Type<QSettings::Status> rb_cQSettingsStatus =
+        // RubyQt6::QtCore::QSettings::Status
+        define_qenum_under<QSettings::Status>(rb_cQSettings, "Status");
+        define_qenum_value_under(rb_cQSettingsStatus, "NoError", QSettings::Status::NoError);
+        define_qenum_value_under(rb_cQSettingsStatus, "AccessError", QSettings::Status::AccessError);
+        define_qenum_value_under(rb_cQSettingsStatus, "FormatError", QSettings::Status::FormatError);
+}

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

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