ruby-qt6-qtcore 1.0.0

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

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

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

@@ -0,0 +1,53 @@
+#include "qmargins-rb.hpp"
+#include <qmargins.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQMargins;
+Rice::Class rb_cQMarginsF;
+
+void Init_qmargins(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQMargins =
+        // RubyQt6::QtCore::QMargins
+        define_class_under<QMargins>(rb_mQt6QtCore, "QMargins")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_operator_equal", [](QMargins *lhs, QMargins  *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
+            .define_singleton_function("_operator_equal", [](QMargins *lhs, QMarginsF *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
+            // Constructor
+            .define_constructor(Constructor<QMargins>())
+            .define_constructor(Constructor<QMargins, int, int, int, int>(), Arg("left"), Arg("top"), Arg("right"), Arg("bottom"))
+            // Public Functions
+            .define_method("bottom", &QMargins::bottom)
+            .define_method("null?", &QMargins::isNull)
+            .define_method("left", &QMargins::left)
+            .define_method("right", &QMargins::right)
+            .define_method("set_bottom", &QMargins::setBottom, Arg("bottom"))
+            .define_method("set_left", &QMargins::setLeft, Arg("left"))
+            .define_method("set_right", &QMargins::setRight, Arg("right"))
+            .define_method("set_top", &QMargins::setTop, Arg("top"))
+            .define_method("to_margins_f", &QMargins::toMarginsF)
+            .define_method("top", &QMargins::top);
+
+    rb_cQMarginsF =
+        // RubyQt6::QtCore::QMarginsF
+        define_class_under<QMarginsF>(rb_mQt6QtCore, "QMarginsF")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_operator_equal", [](QMarginsF *lhs, QMargins  *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
+            .define_singleton_function("_operator_equal", [](QMarginsF *lhs, QMarginsF *rhs) -> bool { return *lhs == *rhs; }, Arg("lhs"), Arg("rhs"))
+            // Constructor
+            .define_constructor(Constructor<QMarginsF>())
+            .define_constructor(Constructor<QMarginsF, qreal, qreal, qreal, qreal>(), Arg("left"), Arg("top"), Arg("right"), Arg("bottom"))
+            .define_constructor(Constructor<QMarginsF, const QMargins &>(), Arg("margins"))
+            // Public Functions
+            .define_method("bottom", &QMarginsF::bottom)
+            .define_method("null?", &QMarginsF::isNull)
+            .define_method("left", &QMarginsF::left)
+            .define_method("right", &QMarginsF::right)
+            .define_method("set_bottom", &QMarginsF::setBottom, Arg("bottom"))
+            .define_method("set_left", &QMarginsF::setLeft, Arg("left"))
+            .define_method("set_right", &QMarginsF::setRight, Arg("right"))
+            .define_method("set_top", &QMarginsF::setTop, Arg("top"))
+            .define_method("to_margins", &QMarginsF::toMargins)
+            .define_method("top", &QMarginsF::top);
+}

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

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

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

@@ -0,0 +1,16 @@
+#include "qmetaclassinfo-rb.hpp"
+#include <qmetaobject.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQMetaClassInfo;
+
+void Init_qmetaclassinfo(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQMetaClassInfo =
+        // RubyQt6::QtCore::QMetaClassInfo
+        define_class_under<QMetaClassInfo>(rb_mQt6QtCore, "QMetaClassInfo")
+            // Public Functions
+            .define_method("name", &QMetaClassInfo::name)
+            .define_method("value", &QMetaClassInfo::value);
+}

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

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

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

@@ -0,0 +1,66 @@
+#include "qmetamethod-rb.hpp"
+#include <qmetaobject.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQMetaMethod;
+
+void Init_qmetamethod(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQMetaMethod =
+        // RubyQt6::QtCore::QMetaMethod
+        define_class_under<QMetaMethod>(rb_mQt6QtCore, "QMetaMethod")
+            // Public Functions
+            .define_method("access", &QMetaMethod::access)
+            .define_method("attributes", &QMetaMethod::attributes)
+            .define_method("enclosing_meta_object", &QMetaMethod::enclosingMetaObject)
+            .define_method("get_parameter_types", &QMetaMethod::getParameterTypes, Arg("types"))
+            .define_method<bool (QMetaMethod::*)(QObject *, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument) const>("invoke", &QMetaMethod::invoke, Arg("object"), Arg("val0"), Arg("val1") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val2") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val3") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val4") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val5") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val6") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val7") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val8") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val9") = static_cast<QGenericArgument>(QGenericArgument()))
+            .define_method<bool (QMetaMethod::*)(QObject *, QGenericReturnArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument) const>("invoke", &QMetaMethod::invoke, Arg("object"), Arg("return_value"), Arg("val0") = static_cast<QGenericArgument>(QGenericArgument(nullptr)), Arg("val1") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val2") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val3") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val4") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val5") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val6") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val7") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val8") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val9") = static_cast<QGenericArgument>(QGenericArgument()))
+            .define_method<bool (QMetaMethod::*)(QObject *, Qt::ConnectionType, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument) const>("invoke", &QMetaMethod::invoke, Arg("object"), Arg("connection_type"), Arg("val0"), Arg("val1") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val2") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val3") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val4") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val5") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val6") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val7") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val8") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val9") = static_cast<QGenericArgument>(QGenericArgument()))
+            .define_method<bool (QMetaMethod::*)(QObject *, Qt::ConnectionType, QGenericReturnArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument) const>("invoke", &QMetaMethod::invoke, Arg("object"), Arg("connection_type"), Arg("return_value"), Arg("val0") = static_cast<QGenericArgument>(QGenericArgument(nullptr)), Arg("val1") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val2") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val3") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val4") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val5") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val6") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val7") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val8") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val9") = static_cast<QGenericArgument>(QGenericArgument()))
+            .define_method<bool (QMetaMethod::*)(void *, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument) const>("invoke_on_gadget", &QMetaMethod::invokeOnGadget, Arg("gadget"), Arg("val0"), Arg("val1") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val2") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val3") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val4") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val5") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val6") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val7") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val8") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val9") = static_cast<QGenericArgument>(QGenericArgument()))
+            .define_method<bool (QMetaMethod::*)(void *, QGenericReturnArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument, QGenericArgument) const>("invoke_on_gadget", &QMetaMethod::invokeOnGadget, Arg("gadget"), Arg("return_value"), Arg("val0") = static_cast<QGenericArgument>(QGenericArgument(nullptr)), Arg("val1") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val2") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val3") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val4") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val5") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val6") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val7") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val8") = static_cast<QGenericArgument>(QGenericArgument()), Arg("val9") = static_cast<QGenericArgument>(QGenericArgument()))
+            .define_method("const?", &QMetaMethod::isConst)
+            .define_method("valid?", &QMetaMethod::isValid)
+            .define_method("method_index", &QMetaMethod::methodIndex)
+            .define_method("method_signature", &QMetaMethod::methodSignature)
+            .define_method("method_type", &QMetaMethod::methodType)
+            .define_method("name", &QMetaMethod::name)
+            .define_method("name_view", &QMetaMethod::nameView)
+            .define_method("parameter_count", &QMetaMethod::parameterCount)
+            .define_method("parameter_meta_type", &QMetaMethod::parameterMetaType, Arg("index"))
+            .define_method("parameter_names", &QMetaMethod::parameterNames)
+            .define_method("parameter_type", &QMetaMethod::parameterType, Arg("index"))
+            .define_method("parameter_type_name", &QMetaMethod::parameterTypeName, Arg("index"))
+            .define_method("parameter_types", &QMetaMethod::parameterTypes)
+            .define_method("relative_method_index", &QMetaMethod::relativeMethodIndex)
+            .define_method("return_meta_type", &QMetaMethod::returnMetaType)
+            .define_method("return_type", &QMetaMethod::returnType)
+            .define_method("revision", &QMetaMethod::revision)
+            .define_method("tag", &QMetaMethod::tag)
+            .define_method("type_name", &QMetaMethod::typeName);
+
+    Data_Type<QMetaMethod::Access> rb_cQMetaMethodAccess =
+        // RubyQt6::QtCore::QMetaMethod::Access
+        define_qenum_under<QMetaMethod::Access>(rb_cQMetaMethod, "Access");
+        define_qenum_value_under(rb_cQMetaMethodAccess, "Private", QMetaMethod::Access::Private);
+        define_qenum_value_under(rb_cQMetaMethodAccess, "Protected", QMetaMethod::Access::Protected);
+        define_qenum_value_under(rb_cQMetaMethodAccess, "Public", QMetaMethod::Access::Public);
+
+    Data_Type<QMetaMethod::Attributes> rb_cQMetaMethodAttributes =
+        // RubyQt6::QtCore::QMetaMethod::Attributes
+        define_qenum_under<QMetaMethod::Attributes>(rb_cQMetaMethod, "Attributes");
+        define_qenum_value_under(rb_cQMetaMethodAttributes, "Compatibility", QMetaMethod::Attributes::Compatibility);
+        define_qenum_value_under(rb_cQMetaMethodAttributes, "Cloned", QMetaMethod::Attributes::Cloned);
+        define_qenum_value_under(rb_cQMetaMethodAttributes, "Scriptable", QMetaMethod::Attributes::Scriptable);
+
+    Data_Type<QMetaMethod::MethodType> rb_cQMetaMethodMethodType =
+        // RubyQt6::QtCore::QMetaMethod::MethodType
+        define_qenum_under<QMetaMethod::MethodType>(rb_cQMetaMethod, "MethodType");
+        define_qenum_value_under(rb_cQMetaMethodMethodType, "Method", QMetaMethod::MethodType::Method);
+        define_qenum_value_under(rb_cQMetaMethodMethodType, "Signal", QMetaMethod::MethodType::Signal);
+        define_qenum_value_under(rb_cQMetaMethodMethodType, "Slot", QMetaMethod::MethodType::Slot);
+        define_qenum_value_under(rb_cQMetaMethodMethodType, "Constructor", QMetaMethod::MethodType::Constructor);
+}

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

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

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

@@ -0,0 +1,49 @@
+#include "qmetaobject-rb.hpp"
+#include <qmetaobject.h>
+#include <qobjectdefs.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQMetaObject;
+Rice::Class rb_cQMetaObjectConnection;
+
+void Init_qmetaobject(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQMetaObject =
+        // RubyQt6::QtCore::QMetaObject
+        define_class_under<QMetaObject>(rb_mQt6QtCore, "QMetaObject")
+            // Public Functions
+            .define_method<QObject *(QMetaObject::*)(QObject *) const>("cast", &QMetaObject::cast, Arg("obj"))
+            .define_method<const QObject *(QMetaObject::*)(const QObject *) const>("cast", &QMetaObject::cast, Arg("obj"))
+            .define_method("class_info", &QMetaObject::classInfo, Arg("index"))
+            .define_method("class_info_count", &QMetaObject::classInfoCount)
+            .define_method("class_info_offset", &QMetaObject::classInfoOffset)
+            .define_method("class_name", &QMetaObject::className)
+            .define_method("constructor", &QMetaObject::constructor, Arg("index"))
+            .define_method("constructor_count", &QMetaObject::constructorCount)
+            .define_method("enumerator", &QMetaObject::enumerator, Arg("index"))
+            .define_method("enumerator_count", &QMetaObject::enumeratorCount)
+            .define_method("enumerator_offset", &QMetaObject::enumeratorOffset)
+            .define_method("index_of_class_info", &QMetaObject::indexOfClassInfo, Arg("name"))
+            .define_method("index_of_constructor", &QMetaObject::indexOfConstructor, Arg("constructor"))
+            .define_method("index_of_enumerator", &QMetaObject::indexOfEnumerator, Arg("name"))
+            .define_method("index_of_method", &QMetaObject::indexOfMethod, Arg("method"))
+            .define_method("index_of_property", &QMetaObject::indexOfProperty, Arg("name"))
+            .define_method("index_of_signal", &QMetaObject::indexOfSignal, Arg("signal"))
+            .define_method("index_of_slot", &QMetaObject::indexOfSlot, Arg("slot"))
+            .define_method("inherits", &QMetaObject::inherits, Arg("meta_object"))
+            .define_method("meta_type", &QMetaObject::metaType)
+            .define_method("method", &QMetaObject::method, Arg("index"))
+            .define_method("method_count", &QMetaObject::methodCount)
+            .define_method("method_offset", &QMetaObject::methodOffset)
+            .define_method("property", &QMetaObject::property, Arg("index"))
+            .define_method("property_count", &QMetaObject::propertyCount)
+            .define_method("property_offset", &QMetaObject::propertyOffset)
+            .define_method("super_class", &QMetaObject::superClass)
+            .define_method("tr", &QMetaObject::tr, Arg("s"), Arg("c"), Arg("n") = static_cast<int>(-1))
+            .define_method("user_property", &QMetaObject::userProperty);
+
+    rb_cQMetaObjectConnection =
+        // RubyQt6::QtCore::QMetaObject::Connection
+        define_class_under<QMetaObject::Connection>(rb_cQMetaObject, "Connection");
+}

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

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

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

@@ -0,0 +1,157 @@
+#include "qmetaobjectbuilder-rb.hpp"
+#include "private/qmetaobjectbuilder_p.h"
+
+using namespace Rice;
+
+Rice::Class rb_cQMetaObjectBuilder;
+Rice::Class rb_cQMetaMethodBuilder;
+Rice::Class rb_cQMetaPropertyBuilder;
+Rice::Class rb_cQMetaEnumBuilder;
+
+void Init_qmetaobjectbuilder(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQMetaObjectBuilder =
+        // RubyQt6::QtCore::QMetaObjectBuilder
+        define_class_under<QMetaObjectBuilder>(rb_mQt6QtCore, "QMetaObjectBuilder")
+            // Constructor
+            .define_constructor(Constructor<QMetaObjectBuilder>())
+            // Public Functions
+            .define_method("_add_class_info", &QMetaObjectBuilder::addClassInfo, Arg("name"), Arg("value"))
+            .define_method<QMetaMethodBuilder (QMetaObjectBuilder::*)(const QByteArray &)>("add_constructor", &QMetaObjectBuilder::addConstructor, Arg("signature"))
+            .define_method<QMetaMethodBuilder (QMetaObjectBuilder::*)(const QMetaMethod &)>("add_constructor", &QMetaObjectBuilder::addConstructor, Arg("prototype"))
+            .define_method<QMetaEnumBuilder (QMetaObjectBuilder::*)(const QByteArray &)>("add_enumerator", &QMetaObjectBuilder::addEnumerator, Arg("name"))
+            .define_method<QMetaEnumBuilder (QMetaObjectBuilder::*)(const QMetaEnum &)>("add_enumerator", &QMetaObjectBuilder::addEnumerator, Arg("prototype"))
+            .define_method("add_meta_object", &QMetaObjectBuilder::addMetaObject, Arg("prototype"), Arg("members") = static_cast<QMetaObjectBuilder::AddMembers>(QMetaObjectBuilder::AddMember::AllMembers))
+            .define_method<QMetaMethodBuilder (QMetaObjectBuilder::*)(const QByteArray &)>("add_method", &QMetaObjectBuilder::addMethod, Arg("signature"))
+            .define_method<QMetaMethodBuilder (QMetaObjectBuilder::*)(const QByteArray &, const QByteArray &)>("add_method", &QMetaObjectBuilder::addMethod, Arg("signature"), Arg("return_type"))
+            .define_method<QMetaMethodBuilder (QMetaObjectBuilder::*)(const QMetaMethod &)>("add_method", &QMetaObjectBuilder::addMethod, Arg("prototype"))
+            .define_method<QMetaPropertyBuilder (QMetaObjectBuilder::*)(const QByteArray &, const QByteArray &, QMetaType, int)>("add_property", &QMetaObjectBuilder::addProperty, Arg("name"), Arg("type"), Arg("meta_type"), Arg("notifier_id") = static_cast<int>(-1))
+            .define_method<QMetaPropertyBuilder (QMetaObjectBuilder::*)(const QByteArray &, const QByteArray &, int)>("add_property", &QMetaObjectBuilder::addProperty, Arg("name"), Arg("type"), Arg("notifier_id") = static_cast<int>(-1))
+            .define_method<QMetaPropertyBuilder (QMetaObjectBuilder::*)(const QMetaProperty &)>("add_property", &QMetaObjectBuilder::addProperty, Arg("prototype"))
+            .define_method("add_related_meta_object", &QMetaObjectBuilder::addRelatedMetaObject, Arg("meta"))
+            .define_method("_add_signal", &QMetaObjectBuilder::addSignal, Arg("signature"))
+            .define_method("_add_slot", &QMetaObjectBuilder::addSlot, Arg("signature"))
+            .define_method("class_info_count", &QMetaObjectBuilder::classInfoCount)
+            .define_method("class_info_name", &QMetaObjectBuilder::classInfoName, Arg("index"))
+            .define_method("class_info_value", &QMetaObjectBuilder::classInfoValue, Arg("index"))
+            .define_method("class_name", &QMetaObjectBuilder::className)
+            .define_method("constructor", &QMetaObjectBuilder::constructor, Arg("index"))
+            .define_method("constructor_count", &QMetaObjectBuilder::constructorCount)
+            .define_method("enumerator", &QMetaObjectBuilder::enumerator, Arg("index"))
+            .define_method("enumerator_count", &QMetaObjectBuilder::enumeratorCount)
+            .define_method("flags", &QMetaObjectBuilder::flags)
+            .define_method("index_of_class_info", &QMetaObjectBuilder::indexOfClassInfo, Arg("name"))
+            .define_method("index_of_constructor", &QMetaObjectBuilder::indexOfConstructor, Arg("signature"))
+            .define_method("index_of_enumerator", &QMetaObjectBuilder::indexOfEnumerator, Arg("name"))
+            .define_method("index_of_method", &QMetaObjectBuilder::indexOfMethod, Arg("signature"))
+            .define_method("index_of_property", &QMetaObjectBuilder::indexOfProperty, Arg("name"))
+            .define_method("index_of_signal", &QMetaObjectBuilder::indexOfSignal, Arg("signature"))
+            .define_method("index_of_slot", &QMetaObjectBuilder::indexOfSlot, Arg("signature"))
+            .define_method("method", &QMetaObjectBuilder::method, Arg("index"))
+            .define_method("method_count", &QMetaObjectBuilder::methodCount)
+            .define_method("property", &QMetaObjectBuilder::property, Arg("index"))
+            .define_method("property_count", &QMetaObjectBuilder::propertyCount)
+            .define_method("related_meta_object", &QMetaObjectBuilder::relatedMetaObject, Arg("index"))
+            .define_method("related_meta_object_count", &QMetaObjectBuilder::relatedMetaObjectCount)
+            .define_method("remove_class_info", &QMetaObjectBuilder::removeClassInfo, Arg("index"))
+            .define_method("remove_constructor", &QMetaObjectBuilder::removeConstructor, Arg("index"))
+            .define_method("remove_enumerator", &QMetaObjectBuilder::removeEnumerator, Arg("index"))
+            .define_method("remove_method", &QMetaObjectBuilder::removeMethod, Arg("index"))
+            .define_method("remove_property", &QMetaObjectBuilder::removeProperty, Arg("index"))
+            .define_method("remove_related_meta_object", &QMetaObjectBuilder::removeRelatedMetaObject, Arg("index"))
+            .define_method("_set_class_name", &QMetaObjectBuilder::setClassName, Arg("name"))
+            .define_method("set_flags", &QMetaObjectBuilder::setFlags, Arg("flags"))
+            // .define_method("set_static_metacall_function", &QMetaObjectBuilder::setStaticMetacallFunction, Arg("value"))
+            .define_method("set_super_class", &QMetaObjectBuilder::setSuperClass, Arg("meta"))
+            // .define_method("static_metacall_function", &QMetaObjectBuilder::staticMetacallFunction)
+            .define_method("super_class", &QMetaObjectBuilder::superClass)
+            .define_method("to_meta_object", &QMetaObjectBuilder::toMetaObject);
+
+    rb_cQMetaMethodBuilder =
+        // RubyQt6::QtCore::QMetaMethodBuilder
+        define_class_under<QMetaMethodBuilder>(rb_mQt6QtCore, "QMetaMethodBuilder")
+            // Public Functions
+            .define_method("access", &QMetaMethodBuilder::access)
+            .define_method("attributes", &QMetaMethodBuilder::attributes)
+            .define_method("index", &QMetaMethodBuilder::index)
+            .define_method("const?", &QMetaMethodBuilder::isConst)
+            .define_method("method_type", &QMetaMethodBuilder::methodType)
+            .define_method("parameter_names", &QMetaMethodBuilder::parameterNames)
+            .define_method("parameter_types", &QMetaMethodBuilder::parameterTypes)
+            .define_method("return_type", &QMetaMethodBuilder::returnType)
+            .define_method("revision", &QMetaMethodBuilder::revision)
+            .define_method("set_access", &QMetaMethodBuilder::setAccess, Arg("value"))
+            .define_method("set_attributes", &QMetaMethodBuilder::setAttributes, Arg("value"))
+            .define_method("set_const", &QMetaMethodBuilder::setConst, Arg("method_is_const") = static_cast<bool>(true))
+            .define_method("set_parameter_names", &QMetaMethodBuilder::setParameterNames, Arg("value"))
+            .define_method("_set_return_type", &QMetaMethodBuilder::setReturnType, Arg("value"))
+            .define_method("set_revision", &QMetaMethodBuilder::setRevision, Arg("revision"))
+            .define_method("set_tag", &QMetaMethodBuilder::setTag, Arg("value"))
+            .define_method("signature", &QMetaMethodBuilder::signature)
+            .define_method("tag", &QMetaMethodBuilder::tag);
+
+    rb_cQMetaPropertyBuilder =
+        // RubyQt6::QtCore::QMetaPropertyBuilder
+        define_class_under<QMetaPropertyBuilder>(rb_mQt6QtCore, "QMetaPropertyBuilder")
+            // Public Functions
+            .define_method("has_notify_signal", &QMetaPropertyBuilder::hasNotifySignal)
+            .define_method("has_std_cpp_set", &QMetaPropertyBuilder::hasStdCppSet)
+            .define_method("index", &QMetaPropertyBuilder::index)
+            .define_method("alias?", &QMetaPropertyBuilder::isAlias)
+            .define_method("bindable?", &QMetaPropertyBuilder::isBindable)
+            .define_method("constant?", &QMetaPropertyBuilder::isConstant)
+            .define_method("designable?", &QMetaPropertyBuilder::isDesignable)
+            // .define_method("editable?", &QMetaPropertyBuilder::isEditable)
+            .define_method("enum_or_flag?", &QMetaPropertyBuilder::isEnumOrFlag)
+            .define_method("final?", &QMetaPropertyBuilder::isFinal)
+            .define_method("readable?", &QMetaPropertyBuilder::isReadable)
+            .define_method("resettable?", &QMetaPropertyBuilder::isResettable)
+            .define_method("scriptable?", &QMetaPropertyBuilder::isScriptable)
+            .define_method("stored?", &QMetaPropertyBuilder::isStored)
+            .define_method("user?", &QMetaPropertyBuilder::isUser)
+            .define_method("writable?", &QMetaPropertyBuilder::isWritable)
+            .define_method("name", &QMetaPropertyBuilder::name)
+            .define_method("notify_signal", &QMetaPropertyBuilder::notifySignal)
+            .define_method("remove_notify_signal", &QMetaPropertyBuilder::removeNotifySignal)
+            .define_method("revision", &QMetaPropertyBuilder::revision)
+            .define_method("set_alias", &QMetaPropertyBuilder::setAlias, Arg("value"))
+            .define_method("set_bindable", &QMetaPropertyBuilder::setBindable, Arg("value"))
+            .define_method("set_constant", &QMetaPropertyBuilder::setConstant, Arg("value"))
+            .define_method("set_designable", &QMetaPropertyBuilder::setDesignable, Arg("value"))
+            .define_method("set_enum_or_flag", &QMetaPropertyBuilder::setEnumOrFlag, Arg("value"))
+            .define_method("set_final", &QMetaPropertyBuilder::setFinal, Arg("value"))
+            .define_method("set_notify_signal", &QMetaPropertyBuilder::setNotifySignal, Arg("value"))
+            .define_method("set_readable", &QMetaPropertyBuilder::setReadable, Arg("value"))
+            .define_method("set_resettable", &QMetaPropertyBuilder::setResettable, Arg("value"))
+            .define_method("set_revision", &QMetaPropertyBuilder::setRevision, Arg("revision"))
+            .define_method("set_scriptable", &QMetaPropertyBuilder::setScriptable, Arg("value"))
+            .define_method("set_std_cpp_set", &QMetaPropertyBuilder::setStdCppSet, Arg("value"))
+            .define_method("set_stored", &QMetaPropertyBuilder::setStored, Arg("value"))
+            .define_method("set_user", &QMetaPropertyBuilder::setUser, Arg("value"))
+            .define_method("set_writable", &QMetaPropertyBuilder::setWritable, Arg("value"))
+            .define_method("type", &QMetaPropertyBuilder::type);
+
+    rb_cQMetaEnumBuilder =
+        // RubyQt6::QtCore::QMetaEnumBuilder
+        define_class_under<QMetaEnumBuilder>(rb_mQt6QtCore, "QMetaEnumBuilder")
+            // Public Functions
+            .define_method<int (QMetaEnumBuilder::*)(const QByteArray &, int)>("add_key", &QMetaEnumBuilder::addKey, Arg("name"), Arg("value"))
+            .define_method<int (QMetaEnumBuilder::*)(const QByteArray &, quint64)>("add_key", &QMetaEnumBuilder::addKey, Arg("name"), Arg("value"))
+            .define_method("enum_name", &QMetaEnumBuilder::enumName)
+            .define_method("index", &QMetaEnumBuilder::index)
+            .define_method("is64_bit", &QMetaEnumBuilder::is64Bit)
+            .define_method("flag?", &QMetaEnumBuilder::isFlag)
+            .define_method("scoped?", &QMetaEnumBuilder::isScoped)
+            .define_method("key", &QMetaEnumBuilder::key, Arg("index"))
+            .define_method("key_count", &QMetaEnumBuilder::keyCount)
+            .define_method("meta_type", &QMetaEnumBuilder::metaType)
+            .define_method("name", &QMetaEnumBuilder::name)
+            .define_method("remove_key", &QMetaEnumBuilder::removeKey, Arg("index"))
+            .define_method("set_enum_name", &QMetaEnumBuilder::setEnumName, Arg("alias"))
+            .define_method("set_is64_bit", &QMetaEnumBuilder::setIs64Bit, Arg("value"))
+            .define_method("set_is_flag", &QMetaEnumBuilder::setIsFlag, Arg("value"))
+            .define_method("set_is_scoped", &QMetaEnumBuilder::setIsScoped, Arg("value"))
+            .define_method("set_meta_type", &QMetaEnumBuilder::setMetaType, Arg("meta_type"))
+            .define_method("value", &QMetaEnumBuilder::value, Arg("index"))
+            .define_method("value64", &QMetaEnumBuilder::value64, Arg("index"));
+}

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

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

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

@@ -0,0 +1,109 @@
+#include "qmetatype-rb.hpp"
+#include <qmetatype.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQMetaType;
+
+void Init_qmetatype(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQMetaType =
+        // RubyQt6::QtCore::QMetaType
+        define_class_under<QMetaType>(rb_mQt6QtCore, "QMetaType")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("from_name", [](const char *name) -> QMetaType { return QMetaType::fromName(name); })
+            // Constructor
+            .define_constructor(Constructor<QMetaType, int>(), Arg("type_id"))
+            // Public Functions
+            .define_method("id", &QMetaType::id, Arg("_") = static_cast<int>(0))
+            .define_method("name", &QMetaType::name);
+
+    Data_Type<QMetaType::Type> rb_cQMetaTypeType =
+        // RubyQt6::QtCore::QMetaType::Type
+        define_qenum_under<QMetaType::Type>(rb_cQMetaType, "Type");
+        define_qenum_value_under(rb_cQMetaTypeType, "Bool", QMetaType::Type::Bool);
+        define_qenum_value_under(rb_cQMetaTypeType, "Char", QMetaType::Type::Char);
+        define_qenum_value_under(rb_cQMetaTypeType, "Char16", QMetaType::Type::Char16);
+        define_qenum_value_under(rb_cQMetaTypeType, "Char32", QMetaType::Type::Char32);
+        define_qenum_value_under(rb_cQMetaTypeType, "SChar", QMetaType::Type::SChar);
+        define_qenum_value_under(rb_cQMetaTypeType, "UChar", QMetaType::Type::UChar);
+        define_qenum_value_under(rb_cQMetaTypeType, "Int", QMetaType::Type::Int);
+        define_qenum_value_under(rb_cQMetaTypeType, "Long", QMetaType::Type::Long);
+        define_qenum_value_under(rb_cQMetaTypeType, "LongLong", QMetaType::Type::LongLong);
+        define_qenum_value_under(rb_cQMetaTypeType, "Short", QMetaType::Type::Short);
+        define_qenum_value_under(rb_cQMetaTypeType, "UInt", QMetaType::Type::UInt);
+        define_qenum_value_under(rb_cQMetaTypeType, "ULong", QMetaType::Type::ULong);
+        define_qenum_value_under(rb_cQMetaTypeType, "ULongLong", QMetaType::Type::ULongLong);
+        define_qenum_value_under(rb_cQMetaTypeType, "UShort", QMetaType::Type::UShort);
+        define_qenum_value_under(rb_cQMetaTypeType, "Double", QMetaType::Type::Double);
+        define_qenum_value_under(rb_cQMetaTypeType, "Float", QMetaType::Type::Float);
+        define_qenum_value_under(rb_cQMetaTypeType, "Float16", QMetaType::Type::Float16);
+        define_qenum_value_under(rb_cQMetaTypeType, "Nullptr", QMetaType::Type::Nullptr);
+        define_qenum_value_under(rb_cQMetaTypeType, "Void", QMetaType::Type::Void);
+        define_qenum_value_under(rb_cQMetaTypeType, "VoidStar", QMetaType::Type::VoidStar);
+        define_qenum_value_under(rb_cQMetaTypeType, "QObjectStar", QMetaType::Type::QObjectStar);
+        define_qenum_value_under(rb_cQMetaTypeType, "QBitArray", QMetaType::Type::QBitArray);
+        define_qenum_value_under(rb_cQMetaTypeType, "QBitmap", QMetaType::Type::QBitmap);
+        define_qenum_value_under(rb_cQMetaTypeType, "QBrush", QMetaType::Type::QBrush);
+        define_qenum_value_under(rb_cQMetaTypeType, "QByteArray", QMetaType::Type::QByteArray);
+        define_qenum_value_under(rb_cQMetaTypeType, "QByteArrayList", QMetaType::Type::QByteArrayList);
+        define_qenum_value_under(rb_cQMetaTypeType, "QCborArray", QMetaType::Type::QCborArray);
+        define_qenum_value_under(rb_cQMetaTypeType, "QCborMap", QMetaType::Type::QCborMap);
+        define_qenum_value_under(rb_cQMetaTypeType, "QCborSimpleType", QMetaType::Type::QCborSimpleType);
+        define_qenum_value_under(rb_cQMetaTypeType, "QCborValue", QMetaType::Type::QCborValue);
+        define_qenum_value_under(rb_cQMetaTypeType, "QChar", QMetaType::Type::QChar);
+        define_qenum_value_under(rb_cQMetaTypeType, "QColor", QMetaType::Type::QColor);
+        define_qenum_value_under(rb_cQMetaTypeType, "QColorSpace", QMetaType::Type::QColorSpace);
+        define_qenum_value_under(rb_cQMetaTypeType, "QCursor", QMetaType::Type::QCursor);
+        define_qenum_value_under(rb_cQMetaTypeType, "QDate", QMetaType::Type::QDate);
+        define_qenum_value_under(rb_cQMetaTypeType, "QDateTime", QMetaType::Type::QDateTime);
+        define_qenum_value_under(rb_cQMetaTypeType, "QEasingCurve", QMetaType::Type::QEasingCurve);
+        define_qenum_value_under(rb_cQMetaTypeType, "QFont", QMetaType::Type::QFont);
+        define_qenum_value_under(rb_cQMetaTypeType, "QIcon", QMetaType::Type::QIcon);
+        define_qenum_value_under(rb_cQMetaTypeType, "QImage", QMetaType::Type::QImage);
+        define_qenum_value_under(rb_cQMetaTypeType, "QJsonArray", QMetaType::Type::QJsonArray);
+        define_qenum_value_under(rb_cQMetaTypeType, "QJsonDocument", QMetaType::Type::QJsonDocument);
+        define_qenum_value_under(rb_cQMetaTypeType, "QJsonObject", QMetaType::Type::QJsonObject);
+        define_qenum_value_under(rb_cQMetaTypeType, "QJsonValue", QMetaType::Type::QJsonValue);
+        define_qenum_value_under(rb_cQMetaTypeType, "QKeySequence", QMetaType::Type::QKeySequence);
+        define_qenum_value_under(rb_cQMetaTypeType, "QLine", QMetaType::Type::QLine);
+        define_qenum_value_under(rb_cQMetaTypeType, "QLineF", QMetaType::Type::QLineF);
+        define_qenum_value_under(rb_cQMetaTypeType, "QLocale", QMetaType::Type::QLocale);
+        define_qenum_value_under(rb_cQMetaTypeType, "QMatrix4x4", QMetaType::Type::QMatrix4x4);
+        define_qenum_value_under(rb_cQMetaTypeType, "QModelIndex", QMetaType::Type::QModelIndex);
+        define_qenum_value_under(rb_cQMetaTypeType, "QPalette", QMetaType::Type::QPalette);
+        define_qenum_value_under(rb_cQMetaTypeType, "QPen", QMetaType::Type::QPen);
+        define_qenum_value_under(rb_cQMetaTypeType, "QPersistentModelIndex", QMetaType::Type::QPersistentModelIndex);
+        define_qenum_value_under(rb_cQMetaTypeType, "QPixmap", QMetaType::Type::QPixmap);
+        define_qenum_value_under(rb_cQMetaTypeType, "QPoint", QMetaType::Type::QPoint);
+        define_qenum_value_under(rb_cQMetaTypeType, "QPointF", QMetaType::Type::QPointF);
+        define_qenum_value_under(rb_cQMetaTypeType, "QPolygon", QMetaType::Type::QPolygon);
+        define_qenum_value_under(rb_cQMetaTypeType, "QPolygonF", QMetaType::Type::QPolygonF);
+        define_qenum_value_under(rb_cQMetaTypeType, "QQuaternion", QMetaType::Type::QQuaternion);
+        define_qenum_value_under(rb_cQMetaTypeType, "QRect", QMetaType::Type::QRect);
+        define_qenum_value_under(rb_cQMetaTypeType, "QRectF", QMetaType::Type::QRectF);
+        define_qenum_value_under(rb_cQMetaTypeType, "QRegion", QMetaType::Type::QRegion);
+        define_qenum_value_under(rb_cQMetaTypeType, "QRegularExpression", QMetaType::Type::QRegularExpression);
+        define_qenum_value_under(rb_cQMetaTypeType, "QSizePolicy", QMetaType::Type::QSizePolicy);
+        define_qenum_value_under(rb_cQMetaTypeType, "QSize", QMetaType::Type::QSize);
+        define_qenum_value_under(rb_cQMetaTypeType, "QSizeF", QMetaType::Type::QSizeF);
+        define_qenum_value_under(rb_cQMetaTypeType, "QStringList", QMetaType::Type::QStringList);
+        define_qenum_value_under(rb_cQMetaTypeType, "QString", QMetaType::Type::QString);
+        define_qenum_value_under(rb_cQMetaTypeType, "QTextFormat", QMetaType::Type::QTextFormat);
+        define_qenum_value_under(rb_cQMetaTypeType, "QTextLength", QMetaType::Type::QTextLength);
+        define_qenum_value_under(rb_cQMetaTypeType, "QTime", QMetaType::Type::QTime);
+        define_qenum_value_under(rb_cQMetaTypeType, "QTransform", QMetaType::Type::QTransform);
+        define_qenum_value_under(rb_cQMetaTypeType, "QUrl", QMetaType::Type::QUrl);
+        define_qenum_value_under(rb_cQMetaTypeType, "QUuid", QMetaType::Type::QUuid);
+        define_qenum_value_under(rb_cQMetaTypeType, "QVariantHash", QMetaType::Type::QVariantHash);
+        define_qenum_value_under(rb_cQMetaTypeType, "QVariantList", QMetaType::Type::QVariantList);
+        define_qenum_value_under(rb_cQMetaTypeType, "QVariantMap", QMetaType::Type::QVariantMap);
+        define_qenum_value_under(rb_cQMetaTypeType, "QVariantPair", QMetaType::Type::QVariantPair);
+        define_qenum_value_under(rb_cQMetaTypeType, "QVariant", QMetaType::Type::QVariant);
+        define_qenum_value_under(rb_cQMetaTypeType, "QVector2D", QMetaType::Type::QVector2D);
+        define_qenum_value_under(rb_cQMetaTypeType, "QVector3D", QMetaType::Type::QVector3D);
+        define_qenum_value_under(rb_cQMetaTypeType, "QVector4D", QMetaType::Type::QVector4D);
+        define_qenum_value_under(rb_cQMetaTypeType, "User", QMetaType::Type::User);
+        define_qenum_value_under(rb_cQMetaTypeType, "UnknownType", QMetaType::Type::UnknownType);
+}

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

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

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

@@ -0,0 +1,30 @@
+#include "qmodelindex-rb.hpp"
+#include <qabstractitemmodel.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQModelIndex;
+
+void Init_qmodelindex(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQModelIndex =
+        // RubyQt6::QtCore::QModelIndex
+        define_class_under<QModelIndex>(rb_mQt6QtCore, "QModelIndex")
+            // Constructor
+            .define_constructor(Constructor<QModelIndex>())
+            // Public Functions
+            .define_method("column", &QModelIndex::column)
+            .define_method("const_internal_pointer", &QModelIndex::constInternalPointer)
+            .define_method("data", &QModelIndex::data, Arg("role") = static_cast<int>(Qt::DisplayRole))
+            .define_method("flags", &QModelIndex::flags)
+            .define_method("internal_id", &QModelIndex::internalId)
+            .define_method("internal_pointer", &QModelIndex::internalPointer)
+            .define_method("valid?", &QModelIndex::isValid)
+            .define_method("model", &QModelIndex::model)
+            .define_method("multi_data", &QModelIndex::multiData, Arg("role_data_span"))
+            .define_method("parent", &QModelIndex::parent)
+            .define_method("row", &QModelIndex::row)
+            .define_method("sibling", &QModelIndex::sibling, Arg("row"), Arg("column"))
+            .define_method("sibling_at_column", &QModelIndex::siblingAtColumn, Arg("column"))
+            .define_method("sibling_at_row", &QModelIndex::siblingAtRow, Arg("row"));
+}

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

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