ruby-qt6-qtgui 1.0.0

data/ext/qt6/qtgui/qtextobject-rb.cpp

@@ -0,0 +1,44 @@
+#include "qtextobject-rb.hpp"
+#include <qtextobject.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQTextObject;
+Rice::Class rb_cQTextBlockGroup;
+Rice::Class rb_cQTextFrame;
+
+void Init_qtextobject(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQTextObject =
+        // RubyQt6::QtGui::QTextObject
+        define_class_under<QTextObject, QObject>(rb_mQt6QtGui, "QTextObject")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QTextObject::staticMetaObject; })
+            // Public Functions
+            .define_method("document", &QTextObject::document)
+            .define_method("format", &QTextObject::format)
+            .define_method("format_index", &QTextObject::formatIndex)
+            .define_method("object_index", &QTextObject::objectIndex);
+
+    rb_cQTextBlockGroup =
+        // RubyQt6::QtGui::QTextBlockGroup
+        define_class_under<QTextBlockGroup, QTextObject>(rb_mQt6QtGui, "QTextBlockGroup")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QTextBlockGroup::staticMetaObject; });
+
+    rb_cQTextFrame =
+        // RubyQt6::QtGui::QTextFrame
+        define_class_under<QTextFrame, QTextObject>(rb_mQt6QtGui, "QTextFrame")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QTextFrame::staticMetaObject; })
+            // Public Functions
+            .define_method("child_frames", &QTextFrame::childFrames)
+            .define_method("first_cursor_position", &QTextFrame::firstCursorPosition)
+            .define_method("first_position", &QTextFrame::firstPosition)
+            .define_method("frame_format", &QTextFrame::frameFormat)
+            .define_method("last_cursor_position", &QTextFrame::lastCursorPosition)
+            .define_method("last_position", &QTextFrame::lastPosition)
+            .define_method("layout_data", &QTextFrame::layoutData)
+            .define_method("parent_frame", &QTextFrame::parentFrame)
+            .define_method("set_frame_format", &QTextFrame::setFrameFormat, Arg("format"));
+}

data/ext/qt6/qtgui/qtextobject-rb.hpp

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

data/ext/qt6/qtgui/qtextoption-rb.cpp

@@ -0,0 +1,69 @@
+#include "qtextoption-rb.hpp"
+#include <qtextoption.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QList>
+
+using namespace Rice;
+
+Rice::Class rb_cQTextOption;
+
+void Init_qtextoption(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQTextOption =
+        // RubyQt6::QtGui::QTextOption
+        define_class_under<QTextOption>(rb_mQt6QtGui, "QTextOption")
+            // RubyQt6-Defined Functions
+            .define_method("set_alignment", [](QTextOption *self, Qt::AlignmentFlag alignment) -> void { return self->setAlignment(alignment); }, Arg("alignment"))
+            // Public Functions
+            .define_method("alignment", &QTextOption::alignment)
+            .define_method("flags", &QTextOption::flags)
+            .define_method("set_alignment", &QTextOption::setAlignment, Arg("alignment"))
+            .define_method("set_flags", &QTextOption::setFlags, Arg("flags"))
+            .define_method("set_tab_array", &QTextOption::setTabArray, Arg("tab_stops"))
+            .define_method("set_tab_stop_distance", &QTextOption::setTabStopDistance, Arg("tab_stop_distance"))
+            .define_method("set_tabs", &QTextOption::setTabs, Arg("tab_stops"))
+            .define_method("set_text_direction", &QTextOption::setTextDirection, Arg("a_direction"))
+            .define_method("set_use_design_metrics", &QTextOption::setUseDesignMetrics, Arg("b"))
+            .define_method("set_wrap_mode", &QTextOption::setWrapMode, Arg("wrap"))
+            .define_method("tab_array", &QTextOption::tabArray)
+            .define_method("tab_stop_distance", &QTextOption::tabStopDistance)
+            .define_method("tabs", &QTextOption::tabs)
+            .define_method("text_direction", &QTextOption::textDirection)
+            .define_method("use_design_metrics", &QTextOption::useDesignMetrics)
+            .define_method("wrap_mode", &QTextOption::wrapMode);
+
+    Data_Type<QTextOption::Flag> rb_cQTextOptionFlag =
+        // RubyQt6::QtGui::QTextOption::Flag
+        define_qenum_under<QTextOption::Flag>(rb_cQTextOption, "Flag");
+        define_qenum_value_under(rb_cQTextOptionFlag, "ShowTabsAndSpaces", QTextOption::Flag::ShowTabsAndSpaces);
+        define_qenum_value_under(rb_cQTextOptionFlag, "ShowLineAndParagraphSeparators", QTextOption::Flag::ShowLineAndParagraphSeparators);
+        define_qenum_value_under(rb_cQTextOptionFlag, "AddSpaceForLineAndParagraphSeparators", QTextOption::Flag::AddSpaceForLineAndParagraphSeparators);
+        define_qenum_value_under(rb_cQTextOptionFlag, "SuppressColors", QTextOption::Flag::SuppressColors);
+        define_qenum_value_under(rb_cQTextOptionFlag, "ShowDocumentTerminator", QTextOption::Flag::ShowDocumentTerminator);
+        define_qenum_value_under(rb_cQTextOptionFlag, "ShowDefaultIgnorables", QTextOption::Flag::ShowDefaultIgnorables);
+        define_qenum_value_under(rb_cQTextOptionFlag, "DisableEmojiParsing", QTextOption::Flag::DisableEmojiParsing);
+        define_qenum_value_under(rb_cQTextOptionFlag, "IncludeTrailingSpaces", QTextOption::Flag::IncludeTrailingSpaces);
+
+    Data_Type<QTextOption::TabType> rb_cQTextOptionTabType =
+        // RubyQt6::QtGui::QTextOption::TabType
+        define_qenum_under<QTextOption::TabType>(rb_cQTextOption, "TabType");
+        define_qenum_value_under(rb_cQTextOptionTabType, "LeftTab", QTextOption::TabType::LeftTab);
+        define_qenum_value_under(rb_cQTextOptionTabType, "RightTab", QTextOption::TabType::RightTab);
+        define_qenum_value_under(rb_cQTextOptionTabType, "CenterTab", QTextOption::TabType::CenterTab);
+        define_qenum_value_under(rb_cQTextOptionTabType, "DelimiterTab", QTextOption::TabType::DelimiterTab);
+
+    Data_Type<QTextOption::WrapMode> rb_cQTextOptionWrapMode =
+        // RubyQt6::QtGui::QTextOption::WrapMode
+        define_qenum_under<QTextOption::WrapMode>(rb_cQTextOption, "WrapMode");
+        define_qenum_value_under(rb_cQTextOptionWrapMode, "NoWrap", QTextOption::WrapMode::NoWrap);
+        define_qenum_value_under(rb_cQTextOptionWrapMode, "WordWrap", QTextOption::WrapMode::WordWrap);
+        define_qenum_value_under(rb_cQTextOptionWrapMode, "ManualWrap", QTextOption::WrapMode::ManualWrap);
+        define_qenum_value_under(rb_cQTextOptionWrapMode, "WrapAnywhere", QTextOption::WrapMode::WrapAnywhere);
+        define_qenum_value_under(rb_cQTextOptionWrapMode, "WrapAtWordBoundaryOrAnywhere", QTextOption::WrapMode::WrapAtWordBoundaryOrAnywhere);
+
+    Data_Type<QFlags<QTextOption::Flag>> rb_cQTextOptionFlags =
+        // RubyQt6::QtGui::QTextOption::Flags
+        define_qflags_under<QTextOption::Flag>(rb_cQTextOption, "Flags");
+}

data/ext/qt6/qtgui/qtextoption-rb.hpp

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

data/ext/qt6/qtgui/qtexttable-rb.cpp

@@ -0,0 +1,53 @@
+#include "qtexttable-rb.hpp"
+#include <qtexttable.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQTextTable;
+Rice::Class rb_cQTextTableCell;
+
+void Init_qtexttable(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQTextTable =
+        // RubyQt6::QtGui::QTextTable
+        define_class_under<QTextTable, QTextFrame>(rb_mQt6QtGui, "QTextTable")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QTextTable::staticMetaObject; })
+            // Public Functions
+            .define_method("resize", &QTextTable::resize, Arg("rows"), Arg("cols"))
+            .define_method("insert_rows", &QTextTable::insertRows, Arg("pos"), Arg("num"))
+            .define_method("insert_columns", &QTextTable::insertColumns, Arg("pos"), Arg("num"))
+            .define_method("append_rows", &QTextTable::appendRows, Arg("count"))
+            .define_method("append_columns", &QTextTable::appendColumns, Arg("count"))
+            .define_method("remove_rows", &QTextTable::removeRows, Arg("pos"), Arg("num"))
+            .define_method("remove_columns", &QTextTable::removeColumns, Arg("pos"), Arg("num"))
+            .define_method<void (QTextTable::*)(int, int, int, int)>("merge_cells", &QTextTable::mergeCells, Arg("row"), Arg("col"), Arg("num_rows"), Arg("num_cols"))
+            .define_method<void (QTextTable::*)(const QTextCursor &)>("merge_cells", &QTextTable::mergeCells, Arg("cursor"))
+            .define_method("split_cell", &QTextTable::splitCell, Arg("row"), Arg("col"), Arg("num_rows"), Arg("num_cols"))
+            .define_method("rows", &QTextTable::rows)
+            .define_method("columns", &QTextTable::columns)
+            .define_method<QTextTableCell (QTextTable::*)(int, int) const>("cell_at", &QTextTable::cellAt, Arg("row"), Arg("col"))
+            .define_method<QTextTableCell (QTextTable::*)(int) const>("cell_at", &QTextTable::cellAt, Arg("position"))
+            .define_method<QTextTableCell (QTextTable::*)(const QTextCursor &) const>("cell_at", &QTextTable::cellAt, Arg("c"))
+            .define_method("row_start", &QTextTable::rowStart, Arg("c"))
+            .define_method("row_end", &QTextTable::rowEnd, Arg("c"))
+            .define_method("set_format", &QTextTable::setFormat, Arg("format"))
+            .define_method("format", &QTextTable::format);
+
+    rb_cQTextTableCell =
+        // RubyQt6::QtGui::QTextTableCell
+        define_class_under<QTextTableCell>(rb_mQt6QtGui, "QTextTableCell")
+            // Public Functions
+            .define_method("column", &QTextTableCell::column)
+            .define_method("column_span", &QTextTableCell::columnSpan)
+            .define_method("first_cursor_position", &QTextTableCell::firstCursorPosition)
+            .define_method("first_position", &QTextTableCell::firstPosition)
+            .define_method("format", &QTextTableCell::format)
+            .define_method("valid?", &QTextTableCell::isValid)
+            .define_method("last_cursor_position", &QTextTableCell::lastCursorPosition)
+            .define_method("last_position", &QTextTableCell::lastPosition)
+            .define_method("row", &QTextTableCell::row)
+            .define_method("row_span", &QTextTableCell::rowSpan)
+            .define_method("set_format", &QTextTableCell::setFormat, Arg("format"))
+            .define_method("table_cell_format_index", &QTextTableCell::tableCellFormatIndex);
+}

data/ext/qt6/qtgui/qtexttable-rb.hpp

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

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

@@ -0,0 +1,105 @@
+#include "qtgui-rb.hpp"
+#include "qtguiversion-rb.hpp"
+
+#include "qbrush-rb.hpp"
+#include "qcolor-rb.hpp"
+#include "qcursor-rb.hpp"
+#include "qevent-rb.hpp"
+#include "qfont-rb.hpp"
+#include "qfontdatabase-rb.hpp"
+#include "qfontinfo-rb.hpp"
+#include "qfontmetrics-rb.hpp"
+#include "qicon-rb.hpp"
+#include "qkeysequence-rb.hpp"
+#include "qpaintdevice-rb.hpp"
+#include "qpagedpaintdevice-rb.hpp"
+#include "qimage-rb.hpp"
+#include "qimagewriter-rb.hpp"
+#include "qpicture-rb.hpp"
+#include "qpixmap-rb.hpp"
+#include "qpainter-rb.hpp"
+#include "qpainterpath-rb.hpp"
+#include "qpainterpathstroker-rb.hpp"
+#include "qpalette-rb.hpp"
+#include "qpen-rb.hpp"
+#include "qregion-rb.hpp"
+#include "qtextcursor-rb.hpp"
+#include "qtextformat-rb.hpp"
+#include "qtextoption-rb.hpp"
+#include "qtransform-rb.hpp"
+
+#include "qfilesystemmodel-rb.hpp"
+#include "qstandarditemmodel-rb.hpp"
+#include "qaction-rb.hpp"
+#include "qactiongroup-rb.hpp"
+#include "qclipboard-rb.hpp"
+#include "qguiapplication-rb.hpp"
+#include "qmovie-rb.hpp"
+#include "qscreen-rb.hpp"
+#include "qshortcut-rb.hpp"
+#include "qtextdocument-rb.hpp"
+#include "qtextobject-rb.hpp"
+#include "qtextlist-rb.hpp"
+#include "qtexttable-rb.hpp"
+#include "qvalidator-rb.hpp"
+#include "qwindow-rb.hpp"
+
+#include "t-qtgui-rb.hpp"
+#include "qpolygon-rb.hpp"
+
+extern "C" void Init_qtgui()
+{
+    return Rice::detail::cpp_protect([] {
+        Rice::Module rb_mQt6 = Rice::define_module("RubyQt6");
+        Rice::Module rb_mQt6QtGui = define_module_under(rb_mQt6, "QtGui");
+
+        Init_qtguiversion(rb_mQt6QtGui);
+
+        Init_qbrush(rb_mQt6QtGui);
+        Init_qcolor(rb_mQt6QtGui);
+        Init_qcursor(rb_mQt6QtGui);
+        Init_qevent(rb_mQt6QtGui);
+        Init_qfont(rb_mQt6QtGui);
+        Init_qfontdatabase(rb_mQt6QtGui);
+        Init_qfontinfo(rb_mQt6QtGui);
+        Init_qfontmetrics(rb_mQt6QtGui);
+        Init_qicon(rb_mQt6QtGui);
+        Init_qkeysequence(rb_mQt6QtGui);
+        Init_qpaintdevice(rb_mQt6QtGui);
+        Init_qpagedpaintdevice(rb_mQt6QtGui);
+        Init_qimage(rb_mQt6QtGui);
+        Init_qimagewriter(rb_mQt6QtGui);
+        Init_qpicture(rb_mQt6QtGui);
+        Init_qpixmap(rb_mQt6QtGui);
+        Init_qpainter(rb_mQt6QtGui);
+        Init_qpainterpath(rb_mQt6QtGui);
+        Init_qpainterpathstroker(rb_mQt6QtGui);
+        Init_qpalette(rb_mQt6QtGui);
+        Init_qpen(rb_mQt6QtGui);
+        Init_qregion(rb_mQt6QtGui);
+        Init_qtextcursor(rb_mQt6QtGui);
+        Init_qtextformat(rb_mQt6QtGui);
+        Init_qtextoption(rb_mQt6QtGui);
+        Init_qtransform(rb_mQt6QtGui);
+
+        Init_qfilesystemmodel(rb_mQt6QtGui);
+        Init_qstandarditemmodel(rb_mQt6QtGui);
+        Init_qaction(rb_mQt6QtGui);
+        Init_qactiongroup(rb_mQt6QtGui);
+        Init_qclipboard(rb_mQt6QtGui);
+        Init_qguiapplication(rb_mQt6QtGui);
+        Init_qmovie(rb_mQt6QtGui);
+        Init_qscreen(rb_mQt6QtGui);
+        Init_qshortcut(rb_mQt6QtGui);
+        Init_qtextdocument(rb_mQt6QtGui);
+        Init_qtextobject(rb_mQt6QtGui);
+        Init_qtextlist(rb_mQt6QtGui);
+        Init_qtexttable(rb_mQt6QtGui);
+        Init_qvalidator(rb_mQt6QtGui);
+        Init_qwindow(rb_mQt6QtGui);
+
+        Rice::Module rb_mQt6T = define_module_under(rb_mQt6, "T");
+        Init_t_qtgui(rb_mQt6T);
+        Init_qpolygon(rb_mQt6QtGui);
+    });
+}

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

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

data/ext/qt6/qtgui/qtguiversion-rb.cpp

@@ -0,0 +1,9 @@
+#include "qtguiversion-rb.hpp"
+#include <qtguiversion.h>
+
+using namespace Rice;
+
+void Init_qtguiversion(Rice::Module rb_mQt6QtGui)
+{
+    rb_mQt6QtGui.define_constant("QTGUI_VERSION", QTGUI_VERSION_STR);
+}

data/ext/qt6/qtgui/qtguiversion-rb.hpp

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

data/ext/qt6/qtgui/qtransform-rb.cpp

@@ -0,0 +1,79 @@
+#include "qtransform-rb.hpp"
+#include <qtransform.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQTransform;
+
+void Init_qtransform(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQTransform =
+        // RubyQt6::QtGui::QTransform
+        define_class_under<QTransform>(rb_mQt6QtGui, "QTransform")
+            // Constructor
+            .define_constructor(Constructor<QTransform>())
+            .define_constructor(Constructor<QTransform, qreal, qreal, qreal, qreal, qreal, qreal>(), Arg("h11"), Arg("h12"), Arg("h21"), Arg("h22"), Arg("dx"), Arg("dy"))
+            .define_constructor(Constructor<QTransform, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal, qreal>(), Arg("h11"), Arg("h12"), Arg("h13"), Arg("h21"), Arg("h22"), Arg("h23"), Arg("h31"), Arg("h32"), Arg("h33"))
+            // Public Functions
+            .define_method("adjoint", &QTransform::adjoint)
+            .define_method("as_affine_matrix", &QTransform::asAffineMatrix)
+            .define_method("determinant", &QTransform::determinant)
+            .define_method("dx", &QTransform::dx)
+            .define_method("dy", &QTransform::dy)
+            .define_method("inverted", &QTransform::inverted, Arg("invertible") = static_cast<bool *>(nullptr))
+            .define_method("affine?", &QTransform::isAffine)
+            .define_method("identity?", &QTransform::isIdentity)
+            .define_method("invertible?", &QTransform::isInvertible)
+            .define_method("rotating?", &QTransform::isRotating)
+            .define_method("scaling?", &QTransform::isScaling)
+            .define_method("translating?", &QTransform::isTranslating)
+            .define_method("m11", &QTransform::m11)
+            .define_method("m12", &QTransform::m12)
+            .define_method("m13", &QTransform::m13)
+            .define_method("m21", &QTransform::m21)
+            .define_method("m22", &QTransform::m22)
+            .define_method("m23", &QTransform::m23)
+            .define_method("m31", &QTransform::m31)
+            .define_method("m32", &QTransform::m32)
+            .define_method("m33", &QTransform::m33)
+            .define_method<QLine (QTransform::*)(const QLine &) const>("map", &QTransform::map, Arg("l"))
+            .define_method<QLineF (QTransform::*)(const QLineF &) const>("map", &QTransform::map, Arg("l"))
+            .define_method<QPoint (QTransform::*)(const QPoint &) const>("map", &QTransform::map, Arg("p"))
+            .define_method<QPointF (QTransform::*)(const QPointF &) const>("map", &QTransform::map, Arg("p"))
+            .define_method<QPolygon (QTransform::*)(const QPolygon &) const>("map", &QTransform::map, Arg("a"))
+            .define_method<QPolygonF (QTransform::*)(const QPolygonF &) const>("map", &QTransform::map, Arg("a"))
+            .define_method<QRegion (QTransform::*)(const QRegion &) const>("map", &QTransform::map, Arg("r"))
+            .define_method<void (QTransform::*)(int, int, int *, int *) const>("map", &QTransform::map, Arg("x"), Arg("y"), Arg("tx"), Arg("ty"))
+            .define_method<void (QTransform::*)(qreal, qreal, qreal *, qreal *) const>("map", &QTransform::map, Arg("x"), Arg("y"), Arg("tx"), Arg("ty"))
+            .define_method<QRect (QTransform::*)(const QRect &) const>("map_rect", &QTransform::mapRect, Arg("rect"))
+            .define_method<QRectF (QTransform::*)(const QRectF &) const>("map_rect", &QTransform::mapRect, Arg("rect"))
+            .define_method("map_to_polygon", &QTransform::mapToPolygon, Arg("r"))
+            .define_method("reset", &QTransform::reset)
+            .define_method<QTransform &(QTransform::*)(qreal, Qt::Axis)>("rotate", &QTransform::rotate, Arg("a"), Arg("axis") = static_cast<Qt::Axis>(Qt::ZAxis))
+            .define_method<QTransform &(QTransform::*)(qreal, Qt::Axis, qreal)>("rotate", &QTransform::rotate, Arg("a"), Arg("axis"), Arg("distance_to_plane"))
+            .define_method<QTransform &(QTransform::*)(qreal, Qt::Axis)>("rotate_radians", &QTransform::rotateRadians, Arg("a"), Arg("axis") = static_cast<Qt::Axis>(Qt::ZAxis))
+            .define_method<QTransform &(QTransform::*)(qreal, Qt::Axis, qreal)>("rotate_radians", &QTransform::rotateRadians, Arg("a"), Arg("axis"), Arg("distance_to_plane"))
+            .define_method("scale", &QTransform::scale, Arg("sx"), Arg("sy"))
+            .define_method("set_matrix", &QTransform::setMatrix, Arg("m11"), Arg("m12"), Arg("m13"), Arg("m21"), Arg("m22"), Arg("m23"), Arg("m31"), Arg("m32"), Arg("m33"))
+            .define_method("shear", &QTransform::shear, Arg("sh"), Arg("sv"))
+            .define_method("translate", &QTransform::translate, Arg("dx"), Arg("dy"))
+            .define_method("transposed", &QTransform::transposed)
+            .define_method("type", &QTransform::type)
+            // Static Public Members
+            .define_singleton_function("from_scale", &QTransform::fromScale, Arg("dx"), Arg("dy"))
+            .define_singleton_function("from_translate", &QTransform::fromTranslate, Arg("dx"), Arg("dy"))
+            .define_singleton_function("quad_to_quad", &QTransform::quadToQuad, Arg("one"), Arg("two"), Arg("result"))
+            .define_singleton_function("quad_to_square", &QTransform::quadToSquare, Arg("quad"), Arg("result"))
+            .define_singleton_function("square_to_quad", &QTransform::squareToQuad, Arg("square"), Arg("result"));
+
+    Data_Type<QTransform::TransformationType> rb_cQTransformTransformationType =
+        // RubyQt6::QtGui::QTransform::TransformationType
+        define_qenum_under<QTransform::TransformationType>(rb_cQTransform, "TransformationType");
+        define_qenum_value_under(rb_cQTransformTransformationType, "TxNone", QTransform::TransformationType::TxNone);
+        define_qenum_value_under(rb_cQTransformTransformationType, "TxTranslate", QTransform::TransformationType::TxTranslate);
+        define_qenum_value_under(rb_cQTransformTransformationType, "TxScale", QTransform::TransformationType::TxScale);
+        define_qenum_value_under(rb_cQTransformTransformationType, "TxRotate", QTransform::TransformationType::TxRotate);
+        define_qenum_value_under(rb_cQTransformTransformationType, "TxShear", QTransform::TransformationType::TxShear);
+        define_qenum_value_under(rb_cQTransformTransformationType, "TxProject", QTransform::TransformationType::TxProject);
+}

data/ext/qt6/qtgui/qtransform-rb.hpp

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

data/ext/qt6/qtgui/qvalidator-rb.cpp

@@ -0,0 +1,98 @@
+#include "qvalidator-rb.hpp"
+#include <qvalidator.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQValidator;
+Rice::Class rb_cQDoubleValidator;
+Rice::Class rb_cQIntValidator;
+Rice::Class rb_cQRegularExpressionValidator;
+
+void Init_qvalidator(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQValidator =
+        // RubyQt6::QtGui::QValidator
+        define_class_under<QValidator, QObject>(rb_mQt6QtGui, "QValidator")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QValidator::staticMetaObject; })
+            // Public Functions
+            .define_method("fixup", &QValidator::fixup, Arg("input"))
+            .define_method("locale", &QValidator::locale)
+            .define_method("set_locale", &QValidator::setLocale, Arg("locale"))
+            .define_method("validate", &QValidator::validate, Arg("input"), Arg("pos"))
+            // Signals
+            .define_method("changed", &QValidator::changed);
+
+    Data_Type<QValidator::State> rb_cQValidatorState =
+        // RubyQt6::QtGui::QValidator::State
+        define_qenum_under<QValidator::State>(rb_cQValidator, "State");
+        define_qenum_value_under(rb_cQValidatorState, "Invalid", QValidator::State::Invalid);
+        define_qenum_value_under(rb_cQValidatorState, "Intermediate", QValidator::State::Intermediate);
+        define_qenum_value_under(rb_cQValidatorState, "Acceptable", QValidator::State::Acceptable);
+
+    rb_cQDoubleValidator =
+        // RubyQt6::QtGui::QDoubleValidator
+        define_class_under<QDoubleValidator, QValidator>(rb_mQt6QtGui, "QDoubleValidator")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QDoubleValidator::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QDoubleValidator, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("bottom", &QDoubleValidator::bottom)
+            .define_method("decimals", &QDoubleValidator::decimals)
+            .define_method("fixup", &QDoubleValidator::fixup, Arg("input"))
+            .define_method("notation", &QDoubleValidator::notation)
+            .define_method("set_bottom", &QDoubleValidator::setBottom, Arg("top"))
+            .define_method("set_decimals", &QDoubleValidator::setDecimals, Arg("decimals"))
+            .define_method("set_notation", &QDoubleValidator::setNotation, Arg("notation"))
+            .define_method<void (QDoubleValidator::*)(double, double)>("set_range", &QDoubleValidator::setRange, Arg("bottom"), Arg("top"))
+            .define_method<void (QDoubleValidator::*)(double, double, int)>("set_range", &QDoubleValidator::setRange, Arg("bottom"), Arg("top"), Arg("decimals"))
+            .define_method("set_top", &QDoubleValidator::setTop, Arg("top"))
+            .define_method("top", &QDoubleValidator::top)
+            .define_method("validate", &QDoubleValidator::validate, Arg("input"), Arg("pos"))
+            // Signals
+            .define_method("bottom_changed", &QDoubleValidator::bottomChanged, Arg("bottom"))
+            .define_method("decimals_changed", &QDoubleValidator::decimalsChanged, Arg("decimals"))
+            .define_method("notation_changed", &QDoubleValidator::notationChanged, Arg("notation"))
+            .define_method("top_changed", &QDoubleValidator::topChanged, Arg("top"));
+
+    Data_Type<QDoubleValidator::Notation> rb_cQDoubleValidatorNotation =
+        // RubyQt6::QtGui::QDoubleValidator::Notation
+        define_qenum_under<QDoubleValidator::Notation>(rb_cQDoubleValidator, "Notation");
+        define_qenum_value_under(rb_cQDoubleValidatorNotation, "StandardNotation", QDoubleValidator::Notation::StandardNotation);
+        define_qenum_value_under(rb_cQDoubleValidatorNotation, "ScientificNotation", QDoubleValidator::Notation::ScientificNotation);
+
+    rb_cQIntValidator =
+        // RubyQt6::QtGui::QIntValidator
+        define_class_under<QIntValidator, QValidator>(rb_mQt6QtGui, "QIntValidator")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QIntValidator::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QIntValidator, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("bottom", &QIntValidator::bottom)
+            .define_method("fixup", &QIntValidator::fixup, Arg("input"))
+            .define_method("set_bottom", &QIntValidator::setBottom, Arg("bottom"))
+            .define_method("set_range", &QIntValidator::setRange, Arg("bottom"), Arg("top"))
+            .define_method("set_top", &QIntValidator::setTop, Arg("top"))
+            .define_method("top", &QIntValidator::top)
+            .define_method("validate", &QIntValidator::validate, Arg("input"), Arg("pos"))
+            // Signals
+            .define_method("bottom_changed", &QIntValidator::bottomChanged, Arg("bottom"))
+            .define_method("top_changed", &QIntValidator::topChanged, Arg("top"));
+
+    rb_cQRegularExpressionValidator =
+        // RubyQt6::QtGui::QRegularExpressionValidator
+        define_class_under<QRegularExpressionValidator, QValidator>(rb_mQt6QtGui, "QRegularExpressionValidator")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QRegularExpressionValidator::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QRegularExpressionValidator, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("regular_expression", &QRegularExpressionValidator::regularExpression)
+            // Public Slots
+            .define_method("set_regular_expression", &QRegularExpressionValidator::setRegularExpression, Arg("re"))
+            // Signals
+            .define_method("regular_expression_changed", &QRegularExpressionValidator::regularExpressionChanged, Arg("re"));
+}

data/ext/qt6/qtgui/qvalidator-rb.hpp

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