ruby-qt6-qtwidgets 1.0.0

data/ext/qt6/qtwidgets/qheaderview-rb.cpp

@@ -0,0 +1,110 @@
+#include "qheaderview-rb.hpp"
+#include <qheaderview.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQHeaderView;
+
+void Init_qheaderview(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQHeaderView =
+        // RubyQt6::QtWidgets::QHeaderView
+        define_class_under<QHeaderView, QAbstractItemView>(rb_mQt6QtWidgets, "QHeaderView")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QHeaderView::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QHeaderView, Qt::Orientation, QWidget *>(), Arg("orientation"), Arg("parent"))
+            // Public Functions
+            .define_method("cascading_section_resizes", &QHeaderView::cascadingSectionResizes)
+            .define_method("count", &QHeaderView::count)
+            .define_method("default_alignment", &QHeaderView::defaultAlignment)
+            .define_method("default_section_size", &QHeaderView::defaultSectionSize)
+            .define_method("do_items_layout", &QHeaderView::doItemsLayout)
+            .define_method("hidden_section_count", &QHeaderView::hiddenSectionCount)
+            .define_method("hide_section", &QHeaderView::hideSection, Arg("logical_index"))
+            .define_method("highlight_sections", &QHeaderView::highlightSections)
+            .define_method("first_section_movable?", &QHeaderView::isFirstSectionMovable)
+            .define_method("section_hidden?", &QHeaderView::isSectionHidden, Arg("logical_index"))
+            .define_method("sort_indicator_clearable?", &QHeaderView::isSortIndicatorClearable)
+            .define_method("sort_indicator_shown?", &QHeaderView::isSortIndicatorShown)
+            .define_method("length", &QHeaderView::length)
+            .define_method("logical_index", &QHeaderView::logicalIndex, Arg("visual_index"))
+            .define_method<int (QHeaderView::*)(const QPoint &) const>("logical_index_at", &QHeaderView::logicalIndexAt, Arg("pos"))
+            .define_method<int (QHeaderView::*)(int) const>("logical_index_at", &QHeaderView::logicalIndexAt, Arg("position"))
+            .define_method<int (QHeaderView::*)(int, int) const>("logical_index_at", &QHeaderView::logicalIndexAt, Arg("x"), Arg("y"))
+            .define_method("maximum_section_size", &QHeaderView::maximumSectionSize)
+            .define_method("minimum_section_size", &QHeaderView::minimumSectionSize)
+            .define_method("move_section", &QHeaderView::moveSection, Arg("from"), Arg("to"))
+            .define_method("offset", &QHeaderView::offset)
+            .define_method("orientation", &QHeaderView::orientation)
+            .define_method("reset", &QHeaderView::reset)
+            .define_method("reset_default_section_size", &QHeaderView::resetDefaultSectionSize)
+            .define_method("resize_contents_precision", &QHeaderView::resizeContentsPrecision)
+            .define_method("resize_section", &QHeaderView::resizeSection, Arg("logical_index"), Arg("size"))
+            .define_method<void (QHeaderView::*)(QHeaderView::ResizeMode)>("resize_sections", &QHeaderView::resizeSections, Arg("mode"))
+            .define_method("restore_state", &QHeaderView::restoreState, Arg("state"))
+            .define_method("save_state", &QHeaderView::saveState)
+            .define_method("section_position", &QHeaderView::sectionPosition, Arg("logical_index"))
+            .define_method("section_resize_mode", &QHeaderView::sectionResizeMode, Arg("logical_index"))
+            .define_method("section_size", &QHeaderView::sectionSize, Arg("logical_index"))
+            .define_method("section_size_hint", &QHeaderView::sectionSizeHint, Arg("logical_index"))
+            .define_method("section_viewport_position", &QHeaderView::sectionViewportPosition, Arg("logical_index"))
+            .define_method("sections_clickable", &QHeaderView::sectionsClickable)
+            .define_method("sections_hidden", &QHeaderView::sectionsHidden)
+            .define_method("sections_movable", &QHeaderView::sectionsMovable)
+            .define_method("sections_moved", &QHeaderView::sectionsMoved)
+            .define_method("set_cascading_section_resizes", &QHeaderView::setCascadingSectionResizes, Arg("enable"))
+            .define_method("set_default_alignment", &QHeaderView::setDefaultAlignment, Arg("alignment"))
+            .define_method("set_default_section_size", &QHeaderView::setDefaultSectionSize, Arg("size"))
+            .define_method("set_first_section_movable", &QHeaderView::setFirstSectionMovable, Arg("movable"))
+            .define_method("set_highlight_sections", &QHeaderView::setHighlightSections, Arg("highlight"))
+            .define_method("set_maximum_section_size", &QHeaderView::setMaximumSectionSize, Arg("size"))
+            .define_method("set_minimum_section_size", &QHeaderView::setMinimumSectionSize, Arg("size"))
+            .define_method("set_model", &QHeaderView::setModel, Arg("model"))
+            .define_method("set_resize_contents_precision", &QHeaderView::setResizeContentsPrecision, Arg("precision"))
+            .define_method("set_section_hidden", &QHeaderView::setSectionHidden, Arg("logical_index"), Arg("hide"))
+            .define_method<void (QHeaderView::*)(QHeaderView::ResizeMode)>("set_section_resize_mode", &QHeaderView::setSectionResizeMode, Arg("mode"))
+            .define_method<void (QHeaderView::*)(int, QHeaderView::ResizeMode)>("set_section_resize_mode", &QHeaderView::setSectionResizeMode, Arg("logical_index"), Arg("mode"))
+            .define_method("set_sections_clickable", &QHeaderView::setSectionsClickable, Arg("clickable"))
+            .define_method("set_sections_movable", &QHeaderView::setSectionsMovable, Arg("movable"))
+            .define_method("set_sort_indicator", &QHeaderView::setSortIndicator, Arg("logical_index"), Arg("order"))
+            .define_method("set_sort_indicator_clearable", &QHeaderView::setSortIndicatorClearable, Arg("clearable"))
+            .define_method("set_sort_indicator_shown", &QHeaderView::setSortIndicatorShown, Arg("show"))
+            .define_method("set_stretch_last_section", &QHeaderView::setStretchLastSection, Arg("stretch"))
+            .define_method("set_visible", &QHeaderView::setVisible, Arg("v"))
+            .define_method("show_section", &QHeaderView::showSection, Arg("logical_index"))
+            .define_method("sort_indicator_order", &QHeaderView::sortIndicatorOrder)
+            .define_method("sort_indicator_section", &QHeaderView::sortIndicatorSection)
+            .define_method("stretch_last_section", &QHeaderView::stretchLastSection)
+            .define_method("stretch_section_count", &QHeaderView::stretchSectionCount)
+            .define_method("swap_sections", &QHeaderView::swapSections, Arg("first"), Arg("second"))
+            .define_method("visual_index", &QHeaderView::visualIndex, Arg("logical_index"))
+            .define_method("visual_index_at", &QHeaderView::visualIndexAt, Arg("position"))
+            // Public Slots
+            .define_method("header_data_changed", &QHeaderView::headerDataChanged, Arg("orientation"), Arg("logical_first"), Arg("logical_last"))
+            .define_method("set_offset", &QHeaderView::setOffset, Arg("offset"))
+            .define_method("set_offset_to_last_section", &QHeaderView::setOffsetToLastSection)
+            .define_method("set_offset_to_section_position", &QHeaderView::setOffsetToSectionPosition, Arg("visual_index"))
+            // Signals
+            .define_method("geometries_changed", &QHeaderView::geometriesChanged)
+            .define_method("section_clicked", &QHeaderView::sectionClicked, Arg("logical_index"))
+            .define_method("section_count_changed", &QHeaderView::sectionCountChanged, Arg("old_count"), Arg("new_count"))
+            .define_method("section_double_clicked", &QHeaderView::sectionDoubleClicked, Arg("logical_index"))
+            .define_method("section_entered", &QHeaderView::sectionEntered, Arg("logical_index"))
+            .define_method("section_handle_double_clicked", &QHeaderView::sectionHandleDoubleClicked, Arg("logical_index"))
+            .define_method("section_moved", &QHeaderView::sectionMoved, Arg("logical_index"), Arg("old_visual_index"), Arg("new_visual_index"))
+            .define_method("section_pressed", &QHeaderView::sectionPressed, Arg("logical_index"))
+            .define_method("section_resized", &QHeaderView::sectionResized, Arg("logical_index"), Arg("old_size"), Arg("new_size"))
+            .define_method("sort_indicator_changed", &QHeaderView::sortIndicatorChanged, Arg("logical_index"), Arg("order"))
+            .define_method("sort_indicator_clearable_changed", &QHeaderView::sortIndicatorClearableChanged, Arg("clearable"));
+
+    Data_Type<QHeaderView::ResizeMode> rb_cQHeaderViewResizeMode =
+        // RubyQt6::QtWidgets::QHeaderView::ResizeMode
+        define_qenum_under<QHeaderView::ResizeMode>(rb_cQHeaderView, "ResizeMode");
+        define_qenum_value_under(rb_cQHeaderViewResizeMode, "Interactive", QHeaderView::ResizeMode::Interactive);
+        define_qenum_value_under(rb_cQHeaderViewResizeMode, "Stretch", QHeaderView::ResizeMode::Stretch);
+        define_qenum_value_under(rb_cQHeaderViewResizeMode, "Fixed", QHeaderView::ResizeMode::Fixed);
+        define_qenum_value_under(rb_cQHeaderViewResizeMode, "ResizeToContents", QHeaderView::ResizeMode::ResizeToContents);
+        define_qenum_value_under(rb_cQHeaderViewResizeMode, "Custom", QHeaderView::ResizeMode::Custom);
+}

data/ext/qt6/qtwidgets/qheaderview-rb.hpp

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

data/ext/qt6/qtwidgets/qinputdialog-rb.cpp

@@ -0,0 +1,133 @@
+#include "qinputdialog-rb.hpp"
+#include <qinputdialog.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQInputDialog;
+
+double QInputDialog_get_double(QWidget *parent, const QString &title, const QString &label, double value, double min, double max, int decimals, Object boolean, Qt::WindowFlags flags, double step)
+{
+    bool ok {};
+    double v = QInputDialog::getDouble(parent, title, label, value, min, max, decimals, &ok, flags, step);
+    if (!boolean.is_nil()) boolean.call("value=", ok);
+    return v;
+}
+
+int QInputDialog_get_int(QWidget *parent, const QString &title, const QString &label, int value, int min, int max, int step, Object boolean, Qt::WindowFlags flags)
+{
+    bool ok {};
+    int v = QInputDialog::getInt(parent, title, label, value, min, max, step, &ok, flags);
+    if (!boolean.is_nil()) boolean.call("value=", ok);
+    return v;
+}
+
+QString QInputDialog_get_item(QWidget *parent, const QString &title, const QString &label, const QStringList &items, int current, bool editable, Object boolean, Qt::WindowFlags flags, Qt::InputMethodHints inputMethodHints)
+{
+    bool ok {};
+    QString v = QInputDialog::getItem(parent, title, label, items, current, editable, &ok, flags, inputMethodHints);
+    if (!boolean.is_nil()) boolean.call("value=", ok);
+    return v;
+}
+
+QString QInputDialog_get_multi_line_text(QWidget *parent, const QString &title, const QString &label, const QString &text, Object boolean, Qt::WindowFlags flags, Qt::InputMethodHints inputMethodHints)
+{
+    bool ok {};
+    QString v = QInputDialog::getMultiLineText(parent, title, label, text, &ok, flags, inputMethodHints);
+    if (!boolean.is_nil()) boolean.call("value=", ok);
+    return v;
+}
+
+QString QInputDialog_get_text(QWidget *parent, const QString &title, const QString &label, QLineEdit::EchoMode mode, const QString &text, Object boolean, Qt::WindowFlags flags, Qt::InputMethodHints inputMethodHints)
+{
+    bool ok {};
+    QString v = QInputDialog::getText(parent, title, label, mode, text, &ok, flags, inputMethodHints);
+    if (!boolean.is_nil()) boolean.call("value=", ok);
+    return v;
+}
+
+void Init_qinputdialog(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQInputDialog =
+        // RubyQt6::QtWidgets::QInputDialog
+        define_class_under<QInputDialog, QDialog>(rb_mQt6QtWidgets, "QInputDialog")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("get_double", QInputDialog_get_double, Arg("parent"), Arg("title"), Arg("label"), Arg("value") = static_cast<double>(0), Arg("min_value") = static_cast<double>(-2147483647), Arg("max_value") = static_cast<double>(2147483647), Arg("decimals") = static_cast<int>(1), Arg("ok") = static_cast<Object>(Qnil), Arg("flags") = static_cast<Qt::WindowFlags>(Qt::WindowFlags()), Arg("step") = static_cast<double>(1))
+            .define_singleton_function("get_int", QInputDialog_get_int, Arg("parent"), Arg("title"), Arg("label"), Arg("value") = static_cast<int>(0), Arg("min_value") = static_cast<int>(-2147483647), Arg("max_value") = static_cast<int>(2147483647), Arg("step") = static_cast<int>(1), Arg("ok") = static_cast<Object>(Qnil), Arg("flags") = static_cast<Qt::WindowFlags>(Qt::WindowFlags()))
+            .define_singleton_function("get_item", QInputDialog_get_item, Arg("parent"), Arg("title"), Arg("label"), Arg("items"), Arg("current") = static_cast<int>(0), Arg("editable") = static_cast<bool>(true), Arg("ok") = static_cast<Object>(Qnil), Arg("flags") = static_cast<Qt::WindowFlags>(Qt::WindowFlags()), Arg("input_method_hints") = static_cast<Qt::InputMethodHints>(Qt::ImhNone))
+            .define_singleton_function("get_multi_line_text", QInputDialog_get_multi_line_text, Arg("parent"), Arg("title"), Arg("label"), Arg("text") = static_cast<const QString &>(QString()), Arg("ok") = static_cast<Object>(Qnil), Arg("flags") = static_cast<Qt::WindowFlags>(Qt::WindowFlags()), Arg("input_method_hints") = static_cast<Qt::InputMethodHints>(Qt::ImhNone))
+            .define_singleton_function("get_text", QInputDialog_get_text, Arg("parent"), Arg("title"), Arg("label"), Arg("echo") = static_cast<QLineEdit::EchoMode>(QLineEdit::Normal), Arg("text") = static_cast<const QString &>(QString()), Arg("ok") = static_cast<Object>(Qnil), Arg("flags") = static_cast<Qt::WindowFlags>(Qt::WindowFlags()), Arg("input_method_hints") = static_cast<Qt::InputMethodHints>(Qt::ImhNone))
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QInputDialog::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QInputDialog, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("cancel_button_text", &QInputDialog::cancelButtonText)
+            .define_method("combo_box_items", &QInputDialog::comboBoxItems)
+            .define_method("done", &QInputDialog::done, Arg("result"))
+            .define_method("double_decimals", &QInputDialog::doubleDecimals)
+            .define_method("double_maximum", &QInputDialog::doubleMaximum)
+            .define_method("double_minimum", &QInputDialog::doubleMinimum)
+            .define_method("double_step", &QInputDialog::doubleStep)
+            .define_method("double_value", &QInputDialog::doubleValue)
+            .define_method("input_mode", &QInputDialog::inputMode)
+            .define_method("int_maximum", &QInputDialog::intMaximum)
+            .define_method("int_minimum", &QInputDialog::intMinimum)
+            .define_method("int_step", &QInputDialog::intStep)
+            .define_method("int_value", &QInputDialog::intValue)
+            .define_method("combo_box_editable?", &QInputDialog::isComboBoxEditable)
+            .define_method("label_text", &QInputDialog::labelText)
+            .define_method("ok_button_text", &QInputDialog::okButtonText)
+            .define_method<void (QInputDialog::*)(QObject *, const char *)>("open", &QInputDialog::open, Arg("receiver"), Arg("member"))
+            .define_method("options", &QInputDialog::options)
+            .define_method("set_cancel_button_text", &QInputDialog::setCancelButtonText, Arg("text"))
+            .define_method("set_combo_box_editable", &QInputDialog::setComboBoxEditable, Arg("editable"))
+            .define_method("set_combo_box_items", &QInputDialog::setComboBoxItems, Arg("items"))
+            .define_method("set_double_decimals", &QInputDialog::setDoubleDecimals, Arg("decimals"))
+            .define_method("set_double_maximum", &QInputDialog::setDoubleMaximum, Arg("max"))
+            .define_method("set_double_minimum", &QInputDialog::setDoubleMinimum, Arg("min"))
+            .define_method("set_double_range", &QInputDialog::setDoubleRange, Arg("min"), Arg("max"))
+            .define_method("set_double_step", &QInputDialog::setDoubleStep, Arg("step"))
+            .define_method("set_double_value", &QInputDialog::setDoubleValue, Arg("value"))
+            .define_method("set_input_mode", &QInputDialog::setInputMode, Arg("mode"))
+            .define_method("set_int_maximum", &QInputDialog::setIntMaximum, Arg("max"))
+            .define_method("set_int_minimum", &QInputDialog::setIntMinimum, Arg("min"))
+            .define_method("set_int_range", &QInputDialog::setIntRange, Arg("min"), Arg("max"))
+            .define_method("set_int_step", &QInputDialog::setIntStep, Arg("step"))
+            .define_method("set_int_value", &QInputDialog::setIntValue, Arg("value"))
+            .define_method("set_label_text", &QInputDialog::setLabelText, Arg("text"))
+            .define_method("set_ok_button_text", &QInputDialog::setOkButtonText, Arg("text"))
+            .define_method("set_option", &QInputDialog::setOption, Arg("option"), Arg("on") = static_cast<bool>(true))
+            .define_method("set_options", &QInputDialog::setOptions, Arg("options"))
+            .define_method("set_text_echo_mode", &QInputDialog::setTextEchoMode, Arg("mode"))
+            .define_method("set_text_value", &QInputDialog::setTextValue, Arg("text"))
+            .define_method("set_visible", &QInputDialog::setVisible, Arg("visible"))
+            .define_method("test_option", &QInputDialog::testOption, Arg("option"))
+            .define_method("text_echo_mode", &QInputDialog::textEchoMode)
+            .define_method("text_value", &QInputDialog::textValue)
+            // Signals
+            .define_method("double_value_changed", &QInputDialog::doubleValueChanged, Arg("value"))
+            .define_method("double_value_selected", &QInputDialog::doubleValueSelected, Arg("value"))
+            .define_method("int_value_changed", &QInputDialog::intValueChanged, Arg("value"))
+            .define_method("int_value_selected", &QInputDialog::intValueSelected, Arg("value"))
+            .define_method("text_value_changed", &QInputDialog::textValueChanged, Arg("text"))
+            .define_method("text_value_selected", &QInputDialog::textValueSelected, Arg("text"));
+
+    Data_Type<QInputDialog::InputDialogOption> rb_cQInputDialogInputDialogOption =
+        // RubyQt6::QtWidgets::QInputDialog::InputDialogOption
+        define_qenum_under<QInputDialog::InputDialogOption>(rb_cQInputDialog, "InputDialogOption");
+        define_qenum_value_under(rb_cQInputDialogInputDialogOption, "NoButtons", QInputDialog::InputDialogOption::NoButtons);
+        define_qenum_value_under(rb_cQInputDialogInputDialogOption, "UseListViewForComboBoxItems", QInputDialog::InputDialogOption::UseListViewForComboBoxItems);
+        define_qenum_value_under(rb_cQInputDialogInputDialogOption, "UsePlainTextEditForTextInput", QInputDialog::InputDialogOption::UsePlainTextEditForTextInput);
+
+    Data_Type<QInputDialog::InputMode> rb_cQInputDialogInputMode =
+        // RubyQt6::QtWidgets::QInputDialog::InputMode
+        define_qenum_under<QInputDialog::InputMode>(rb_cQInputDialog, "InputMode");
+        define_qenum_value_under(rb_cQInputDialogInputMode, "TextInput", QInputDialog::InputMode::TextInput);
+        define_qenum_value_under(rb_cQInputDialogInputMode, "IntInput", QInputDialog::InputMode::IntInput);
+        define_qenum_value_under(rb_cQInputDialogInputMode, "DoubleInput", QInputDialog::InputMode::DoubleInput);
+
+    Data_Type<QFlags<QInputDialog::InputDialogOption>> rb_cQInputDialogInputDialogOptions =
+        // RubyQt6::QtWidgets::QInputDialog::InputDialogOptions
+        define_qflags_under<QInputDialog::InputDialogOption>(rb_cQInputDialog, "InputDialogOptions");
+}

data/ext/qt6/qtwidgets/qinputdialog-rb.hpp

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

data/ext/qt6/qtwidgets/qitemdelegate-rb.cpp

@@ -0,0 +1,24 @@
+#include "qitemdelegate-rb.hpp"
+#include <qitemdelegate.h>
+
+#include <QItemEditorFactory>
+
+using namespace Rice;
+
+Rice::Class rb_cQItemDelegate;
+
+void Init_qitemdelegate(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQItemDelegate =
+        // RubyQt6::QtWidgets::QItemDelegate
+        define_class_under<QItemDelegate, QAbstractItemDelegate>(rb_mQt6QtWidgets, "QItemDelegate")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QItemDelegate::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QItemDelegate, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("has_clipping", &QItemDelegate::hasClipping)
+            .define_method("item_editor_factory", &QItemDelegate::itemEditorFactory)
+            .define_method("set_clipping", &QItemDelegate::setClipping, Arg("clip"))
+            .define_method("set_item_editor_factory", &QItemDelegate::setItemEditorFactory, Arg("factory"));
+}

data/ext/qt6/qtwidgets/qitemdelegate-rb.hpp

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

data/ext/qt6/qtwidgets/qkeysequenceedit-rb.cpp

@@ -0,0 +1,31 @@
+#include "qkeysequenceedit-rb.hpp"
+#include <qkeysequenceedit.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQKeySequenceEdit;
+
+void Init_qkeysequenceedit(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQKeySequenceEdit =
+        // RubyQt6::QtWidgets::QKeySequenceEdit
+        define_class_under<QKeySequenceEdit, QWidget>(rb_mQt6QtWidgets, "QKeySequenceEdit")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QKeySequenceEdit::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QKeySequenceEdit, const QKeySequence &, QWidget *>(), Arg("key"), Arg("parent"))
+            // Public Functions
+            .define_method("finishing_key_combinations", &QKeySequenceEdit::finishingKeyCombinations)
+            .define_method("clear_button_enabled?", &QKeySequenceEdit::isClearButtonEnabled)
+            .define_method("key_sequence", &QKeySequenceEdit::keySequence)
+            .define_method("maximum_sequence_length", &QKeySequenceEdit::maximumSequenceLength)
+            .define_method("set_clear_button_enabled", &QKeySequenceEdit::setClearButtonEnabled, Arg("enable"))
+            .define_method("set_finishing_key_combinations", &QKeySequenceEdit::setFinishingKeyCombinations, Arg("finishing_key_combinations"))
+            // Public Slots
+            .define_method("clear", &QKeySequenceEdit::clear)
+            .define_method("set_key_sequence", &QKeySequenceEdit::setKeySequence, Arg("key_sequence"))
+            .define_method("set_maximum_sequence_length", &QKeySequenceEdit::setMaximumSequenceLength, Arg("count"))
+            // Signals
+            .define_method("editing_finished", &QKeySequenceEdit::editingFinished)
+            .define_method("key_sequence_changed", &QKeySequenceEdit::keySequenceChanged, Arg("key_sequence"));
+}

data/ext/qt6/qtwidgets/qkeysequenceedit-rb.hpp

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

data/ext/qt6/qtwidgets/qlabel-rb.cpp

@@ -0,0 +1,59 @@
+#include "qlabel-rb.hpp"
+#include <qlabel.h>
+
+#include <QMovie>
+
+using namespace Rice;
+
+Rice::Class rb_cQLabel;
+
+void Init_qlabel(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQLabel =
+        // RubyQt6::QtWidgets::QLabel
+        define_class_under<QLabel, QFrame>(rb_mQt6QtWidgets, "QLabel")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QLabel::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QLabel, const QString &, QWidget *>(), Arg("text"), Arg("parent"))
+            // Public Functions
+            .define_method("alignment", &QLabel::alignment)
+            .define_method("buddy", &QLabel::buddy)
+            .define_method("has_scaled_contents", &QLabel::hasScaledContents)
+            .define_method("has_selected_text", &QLabel::hasSelectedText)
+            .define_method("indent", &QLabel::indent)
+            .define_method("margin", &QLabel::margin)
+            .define_method("movie", &QLabel::movie)
+            .define_method("open_external_links", &QLabel::openExternalLinks)
+            .define_method<QPicture (QLabel::*)() const>("picture", &QLabel::picture)
+            .define_method<QPixmap (QLabel::*)() const>("pixmap", &QLabel::pixmap)
+            .define_method("resource_provider", &QLabel::resourceProvider)
+            .define_method("selected_text", &QLabel::selectedText)
+            .define_method("selection_start", &QLabel::selectionStart)
+            .define_method("_set_alignment", &QLabel::setAlignment, Arg("alignment"))
+            .define_method("set_buddy", &QLabel::setBuddy, Arg("buddy"))
+            .define_method("set_indent", &QLabel::setIndent, Arg("indent"))
+            .define_method("set_margin", &QLabel::setMargin, Arg("margin"))
+            .define_method("set_open_external_links", &QLabel::setOpenExternalLinks, Arg("open"))
+            .define_method("set_resource_provider", &QLabel::setResourceProvider, Arg("provider"))
+            .define_method("set_scaled_contents", &QLabel::setScaledContents, Arg("enabled"))
+            .define_method("set_selection", &QLabel::setSelection, Arg("start"), Arg("length"))
+            .define_method("set_text_format", &QLabel::setTextFormat, Arg("format"))
+            .define_method("set_text_interaction_flags", &QLabel::setTextInteractionFlags, Arg("flags"))
+            .define_method("set_word_wrap", &QLabel::setWordWrap, Arg("on"))
+            .define_method("text", &QLabel::text)
+            .define_method("text_format", &QLabel::textFormat)
+            .define_method("text_interaction_flags", &QLabel::textInteractionFlags)
+            .define_method("word_wrap", &QLabel::wordWrap)
+            // Public Slots
+            .define_method("clear", &QLabel::clear)
+            .define_method("set_movie", &QLabel::setMovie, Arg("movie"))
+            .define_method<void (QLabel::*)(int)>("set_num", &QLabel::setNum, Arg("num"))
+            .define_method<void (QLabel::*)(double)>("set_num", &QLabel::setNum, Arg("num"))
+            .define_method("set_picture", &QLabel::setPicture, Arg("picture"))
+            .define_method("set_pixmap", &QLabel::setPixmap, Arg("pixmap"))
+            .define_method("_set_text", &QLabel::setText, Arg("text"))
+            // Signals
+            .define_method("link_activated", &QLabel::linkActivated, Arg("link"))
+            .define_method("link_hovered", &QLabel::linkHovered, Arg("link"));
+}

data/ext/qt6/qtwidgets/qlabel-rb.hpp

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

data/ext/qt6/qtwidgets/qlayout-rb.cpp

@@ -0,0 +1,81 @@
+#include "qlayout-rb.hpp"
+#include <qlayout.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QWidget>
+
+using namespace Rice;
+
+Rice::Class rb_cQLayout;
+
+void Init_qlayout(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQLayout =
+        // RubyQt6::QtWidgets::QLayout
+        define_class_under<QLayout, QObject>(rb_mQt6QtWidgets, "QLayout")
+            // RubyQt6-Defined Functions
+            .define_method("set_alignment", [](QLayout *self, QLayout *l, Qt::AlignmentFlag alignment) -> bool { return self->setAlignment(l, alignment); }, Arg("l"), Arg("alignment"))
+            .define_method("set_alignment", [](QLayout *self, QWidget *w, Qt::AlignmentFlag alignment) -> bool { return self->setAlignment(w, alignment); }, Arg("w"), Arg("alignment"))
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QLayout::staticMetaObject; })
+            // Inherits QLayoutItem
+            .define_method("alignment", &QLayout::alignment)
+            .define_method("minimum_height_for_width", &QLayout::minimumHeightForWidth, Arg("w"))
+            .define_method("spacer_item", &QLayout::spacerItem)
+            .define_method("widget", &QLayout::widget)
+            // Public Functions
+            .define_method("activate", &QLayout::activate)
+            .define_method("add_item", &QLayout::addItem, Arg("item"))
+            .define_method("add_widget", &QLayout::addWidget, Arg("widget"))
+            .define_method("contents_margins", &QLayout::contentsMargins)
+            .define_method("contents_rect", &QLayout::contentsRect)
+            .define_method("control_types", &QLayout::controlTypes)
+            .define_method("count", &QLayout::count)
+            .define_method("expanding_directions", &QLayout::expandingDirections)
+            .define_method("geometry", &QLayout::geometry)
+            .define_method("get_contents_margins", &QLayout::getContentsMargins, Arg("left"), Arg("top"), Arg("right"), Arg("bottom"))
+            .define_method<int (QLayout::*)(const QLayoutItem *) const>("index_of", &QLayout::indexOf, Arg("layout_item"))
+            .define_method<int (QLayout::*)(const QWidget *) const>("index_of", &QLayout::indexOf, Arg("widget"))
+            .define_method("invalidate", &QLayout::invalidate)
+            .define_method("empty?", &QLayout::isEmpty)
+            .define_method("enabled?", &QLayout::isEnabled)
+            .define_method("item_at", &QLayout::itemAt, Arg("index"))
+            .define_method("layout", &QLayout::layout)
+            .define_method("maximum_size", &QLayout::maximumSize)
+            .define_method("menu_bar", &QLayout::menuBar)
+            .define_method("minimum_size", &QLayout::minimumSize)
+            .define_method("parent_widget", &QLayout::parentWidget)
+            .define_method("remove_item", &QLayout::removeItem, Arg("item"))
+            .define_method("remove_widget", &QLayout::removeWidget, Arg("widget"))
+            .define_method("replace_widget", &QLayout::replaceWidget, Arg("from"), Arg("to"), Arg("options") = static_cast<Qt::FindChildOptions>(Qt::FindChildrenRecursively))
+            .define_method<bool (QLayout::*)(QLayout *, Qt::Alignment)>("set_alignment", &QLayout::setAlignment, Arg("l"), Arg("alignment"))
+            .define_method<bool (QLayout::*)(QWidget *, Qt::Alignment)>("set_alignment", &QLayout::setAlignment, Arg("w"), Arg("alignment"))
+            .define_method<void (QLayout::*)(const QMargins &)>("set_contents_margins", &QLayout::setContentsMargins, Arg("margins"))
+            .define_method<void (QLayout::*)(int, int, int, int)>("set_contents_margins", &QLayout::setContentsMargins, Arg("left"), Arg("top"), Arg("right"), Arg("bottom"))
+            .define_method("set_enabled", &QLayout::setEnabled, Arg("enabled"))
+            .define_method("set_geometry", &QLayout::setGeometry, Arg("rect"))
+            .define_method("set_menu_bar", &QLayout::setMenuBar, Arg("w"))
+            .define_method("set_size_constraint", &QLayout::setSizeConstraint, Arg("size_constraint"))
+            .define_method("set_spacing", &QLayout::setSpacing, Arg("spacing"))
+            .define_method("size_constraint", &QLayout::sizeConstraint)
+            .define_method("spacing", &QLayout::spacing)
+            .define_method("take_at", &QLayout::takeAt, Arg("index"))
+            .define_method("total_height_for_width", &QLayout::totalHeightForWidth, Arg("w"))
+            .define_method("total_maximum_size", &QLayout::totalMaximumSize)
+            .define_method("total_minimum_height_for_width", &QLayout::totalMinimumHeightForWidth, Arg("w"))
+            .define_method("total_minimum_size", &QLayout::totalMinimumSize)
+            .define_method("total_size_hint", &QLayout::totalSizeHint)
+            .define_method("unset_contents_margins", &QLayout::unsetContentsMargins)
+            .define_method("update", &QLayout::update)
+            // Static Public Members
+            .define_singleton_function("closest_acceptable_size", &QLayout::closestAcceptableSize, Arg("w"), Arg("s"));
+
+    Data_Type<QLayout::SizeConstraint> rb_cQLayoutSizeConstraint =
+        // RubyQt6::QtWidgets::QLayout::SizeConstraint
+        define_qenum_under<QLayout::SizeConstraint>(rb_cQLayout, "SizeConstraint");
+        define_qenum_value_under(rb_cQLayoutSizeConstraint, "SetDefaultConstraint", QLayout::SizeConstraint::SetDefaultConstraint);
+        define_qenum_value_under(rb_cQLayoutSizeConstraint, "SetNoConstraint", QLayout::SizeConstraint::SetNoConstraint);
+        define_qenum_value_under(rb_cQLayoutSizeConstraint, "SetMinimumSize", QLayout::SizeConstraint::SetMinimumSize);
+        define_qenum_value_under(rb_cQLayoutSizeConstraint, "SetFixedSize", QLayout::SizeConstraint::SetFixedSize);
+        define_qenum_value_under(rb_cQLayoutSizeConstraint, "SetMaximumSize", QLayout::SizeConstraint::SetMaximumSize);
+        define_qenum_value_under(rb_cQLayoutSizeConstraint, "SetMinAndMaxSize", QLayout::SizeConstraint::SetMinAndMaxSize);
+}

data/ext/qt6/qtwidgets/qlayout-rb.hpp

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

data/ext/qt6/qtwidgets/qlayoutitem-rb.cpp

@@ -0,0 +1,54 @@
+#include "qlayoutitem-rb.hpp"
+#include <qlayoutitem.h>
+
+#include <QLayout>
+#include <QWidget>
+
+using namespace Rice;
+
+Rice::Class rb_cQLayoutItem;
+Rice::Class rb_cQWidgetItem;
+
+void Init_qlayoutitem(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQLayoutItem =
+        // RubyQt6::QtWidgets::QLayoutItem
+        define_class_under<QLayoutItem>(rb_mQt6QtWidgets, "QLayoutItem")
+            // RubyQt6-Defined Functions
+            .define_method("set_alignment", [](QLayoutItem *self, Qt::AlignmentFlag alignment) -> void { return self->setAlignment(alignment); }, Arg("alignment"))
+            // Public Functions
+            .define_method("alignment", &QLayoutItem::alignment)
+            .define_method("control_types", &QLayoutItem::controlTypes)
+            .define_method("expanding_directions", &QLayoutItem::expandingDirections)
+            .define_method("geometry", &QLayoutItem::geometry)
+            .define_method("invalidate", &QLayoutItem::invalidate)
+            .define_method("empty?", &QLayoutItem::isEmpty)
+            .define_method("layout", &QLayoutItem::layout)
+            .define_method("maximum_size", &QLayoutItem::maximumSize)
+            .define_method("minimum_height_for_width", &QLayoutItem::minimumHeightForWidth, Arg("w"))
+            .define_method("minimum_size", &QLayoutItem::minimumSize)
+            .define_method("set_alignment", &QLayoutItem::setAlignment, Arg("alignment"))
+            .define_method("set_geometry", &QLayoutItem::setGeometry, Arg("rect"))
+            .define_method("size_hint", &QLayoutItem::sizeHint)
+            .define_method("spacer_item", &QLayoutItem::spacerItem)
+            .define_method("widget", &QLayoutItem::widget);
+
+    rb_cQWidgetItem =
+        // RubyQt6::QtWidgets::QWidgetItem
+        define_class_under<QWidgetItem, QLayoutItem>(rb_mQt6QtWidgets, "QWidgetItem")
+            // Constructor
+            .define_constructor(Constructor<QWidgetItem, QWidget *>(), Arg("widget"))
+            // Public Functions
+            .define_method("control_types", &QWidgetItem::controlTypes)
+            .define_method("expanding_directions", &QWidgetItem::expandingDirections)
+            .define_method("geometry", &QWidgetItem::geometry)
+            .define_method("has_height_for_width", &QWidgetItem::hasHeightForWidth)
+            .define_method("height_for_width", &QWidgetItem::heightForWidth, Arg("w"))
+            .define_method("empty?", &QWidgetItem::isEmpty)
+            .define_method("maximum_size", &QWidgetItem::maximumSize)
+            .define_method("minimum_height_for_width", &QWidgetItem::minimumHeightForWidth, Arg("w"))
+            .define_method("minimum_size", &QWidgetItem::minimumSize)
+            .define_method("set_geometry", &QWidgetItem::setGeometry, Arg("r"))
+            .define_method("size_hint", &QWidgetItem::sizeHint)
+            .define_method("widget", &QWidgetItem::widget);
+}

data/ext/qt6/qtwidgets/qlayoutitem-rb.hpp

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

data/ext/qt6/qtwidgets/qlcdnumber-rb.cpp

@@ -0,0 +1,56 @@
+#include "qlcdnumber-rb.hpp"
+#include <qlcdnumber.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQLCDNumber;
+
+void Init_qlcdnumber(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQLCDNumber =
+        // RubyQt6::QtWidgets::QLCDNumber
+        define_class_under<QLCDNumber, QFrame>(rb_mQt6QtWidgets, "QLCDNumber")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QLCDNumber::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QLCDNumber, uint, QWidget *>(), Arg("num"), Arg("parent"))
+            // Public Functions
+            .define_method<bool (QLCDNumber::*)(double) const>("check_overflow", &QLCDNumber::checkOverflow, Arg("num"))
+            .define_method<bool (QLCDNumber::*)(int) const>("check_overflow", &QLCDNumber::checkOverflow, Arg("num"))
+            .define_method("digit_count", &QLCDNumber::digitCount)
+            .define_method("int_value", &QLCDNumber::intValue)
+            .define_method("mode", &QLCDNumber::mode)
+            .define_method("segment_style", &QLCDNumber::segmentStyle)
+            .define_method("set_digit_count", &QLCDNumber::setDigitCount, Arg("n_digits"))
+            .define_method("set_mode", &QLCDNumber::setMode, Arg("mode"))
+            .define_method("set_segment_style", &QLCDNumber::setSegmentStyle, Arg("style"))
+            .define_method("small_decimal_point", &QLCDNumber::smallDecimalPoint)
+            .define_method("value", &QLCDNumber::value)
+            // Public Slots
+            .define_method<void (QLCDNumber::*)(const QString &)>("_display", &QLCDNumber::display, Arg("str"))
+            .define_method<void (QLCDNumber::*)(double)>("_display", &QLCDNumber::display, Arg("num"))
+            .define_method<void (QLCDNumber::*)(int)>("_display", &QLCDNumber::display, Arg("num"))
+            .define_method("set_bin_mode", &QLCDNumber::setBinMode)
+            .define_method("set_dec_mode", &QLCDNumber::setDecMode)
+            .define_method("set_hex_mode", &QLCDNumber::setHexMode)
+            .define_method("set_oct_mode", &QLCDNumber::setOctMode)
+            .define_method("set_small_decimal_point", &QLCDNumber::setSmallDecimalPoint, Arg("enabled"))
+            // Signals
+            .define_method("overflow", &QLCDNumber::overflow);
+
+    Data_Type<QLCDNumber::Mode> rb_cQLCDNumberMode =
+        // RubyQt6::QtWidgets::QLCDNumber::Mode
+        define_qenum_under<QLCDNumber::Mode>(rb_cQLCDNumber, "Mode");
+        define_qenum_value_under(rb_cQLCDNumberMode, "Hex", QLCDNumber::Mode::Hex);
+        define_qenum_value_under(rb_cQLCDNumberMode, "Dec", QLCDNumber::Mode::Dec);
+        define_qenum_value_under(rb_cQLCDNumberMode, "Oct", QLCDNumber::Mode::Oct);
+        define_qenum_value_under(rb_cQLCDNumberMode, "Bin", QLCDNumber::Mode::Bin);
+
+    Data_Type<QLCDNumber::SegmentStyle> rb_cQLCDNumberSegmentStyle =
+        // RubyQt6::QtWidgets::QLCDNumber::SegmentStyle
+        define_qenum_under<QLCDNumber::SegmentStyle>(rb_cQLCDNumber, "SegmentStyle");
+        define_qenum_value_under(rb_cQLCDNumberSegmentStyle, "Outline", QLCDNumber::SegmentStyle::Outline);
+        define_qenum_value_under(rb_cQLCDNumberSegmentStyle, "Filled", QLCDNumber::SegmentStyle::Filled);
+        define_qenum_value_under(rb_cQLCDNumberSegmentStyle, "Flat", QLCDNumber::SegmentStyle::Flat);
+}

data/ext/qt6/qtwidgets/qlcdnumber-rb.hpp

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