ruby-qt6-qtwidgets 1.0.0

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

@@ -0,0 +1,79 @@
+#include "qboxlayout-rb.hpp"
+#include <qboxlayout.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QWidget>
+
+using namespace Rice;
+
+Rice::Class rb_cQBoxLayout;
+Rice::Class rb_cQHBoxLayout;
+Rice::Class rb_cQVBoxLayout;
+
+void Init_qboxlayout(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQBoxLayout =
+        // RubyQt6::QtWidgets::QBoxLayout
+        define_class_under<QBoxLayout, QLayout>(rb_mQt6QtWidgets, "QBoxLayout")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QBoxLayout::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QBoxLayout, QBoxLayout::Direction, QWidget *>(), Arg("direction"), Arg("parent"))
+            // Public Functions
+            .define_method("add_item", &QBoxLayout::addItem, Arg("item"))
+            .define_method("add_layout", &QBoxLayout::addLayout, Arg("layout"), Arg("stretch") = static_cast<int>(0))
+            .define_method("add_spacer_item", &QBoxLayout::addSpacerItem, Arg("item"))
+            .define_method("add_spacing", &QBoxLayout::addSpacing, Arg("size"))
+            .define_method("add_stretch", &QBoxLayout::addStretch, Arg("stretch") = static_cast<int>(0))
+            .define_method("add_strut", &QBoxLayout::addStrut, Arg("strut"))
+            .define_method("add_widget", &QBoxLayout::addWidget, Arg("widget"), Arg("stretch") = static_cast<int>(0), Arg("alignment") = static_cast<Qt::Alignment>(Qt::Alignment()))
+            .define_method("count", &QBoxLayout::count)
+            .define_method("direction", &QBoxLayout::direction)
+            .define_method("expanding_directions", &QBoxLayout::expandingDirections)
+            .define_method("insert_item", &QBoxLayout::insertItem, Arg("index"), Arg("item"))
+            .define_method("insert_layout", &QBoxLayout::insertLayout, Arg("index"), Arg("layout"), Arg("stretch") = static_cast<int>(0))
+            .define_method("insert_spacer_item", &QBoxLayout::insertSpacerItem, Arg("index"), Arg("item"))
+            .define_method("insert_spacing", &QBoxLayout::insertSpacing, Arg("index"), Arg("size"))
+            .define_method("insert_stretch", &QBoxLayout::insertStretch, Arg("index"), Arg("stretch") = static_cast<int>(0))
+            .define_method("insert_widget", &QBoxLayout::insertWidget, Arg("index"), Arg("widget"), Arg("stretch") = static_cast<int>(0), Arg("alignment") = static_cast<Qt::Alignment>(Qt::Alignment()))
+            .define_method("invalidate", &QBoxLayout::invalidate)
+            .define_method("item_at", &QBoxLayout::itemAt, Arg("index"))
+            .define_method("maximum_size", &QBoxLayout::maximumSize)
+            .define_method("minimum_height_for_width", &QBoxLayout::minimumHeightForWidth, Arg("w"))
+            .define_method("minimum_size", &QBoxLayout::minimumSize)
+            .define_method("set_direction", &QBoxLayout::setDirection, Arg("direction"))
+            .define_method("set_geometry", &QBoxLayout::setGeometry, Arg("rect"))
+            .define_method("set_spacing", &QBoxLayout::setSpacing, Arg("spacing"))
+            .define_method("set_stretch", &QBoxLayout::setStretch, Arg("index"), Arg("stretch"))
+            .define_method<bool (QBoxLayout::*)(QLayout *, int)>("set_stretch_factor", &QBoxLayout::setStretchFactor, Arg("l"), Arg("stretch"))
+            .define_method<bool (QBoxLayout::*)(QWidget *, int)>("set_stretch_factor", &QBoxLayout::setStretchFactor, Arg("w"), Arg("stretch"))
+            .define_method("spacing", &QBoxLayout::spacing)
+            .define_method("stretch", &QBoxLayout::stretch, Arg("index"))
+            .define_method("take_at", &QBoxLayout::takeAt, Arg("index"));
+
+    Data_Type<QBoxLayout::Direction> rb_cQBoxLayoutDirection =
+        // RubyQt6::QtWidgets::QBoxLayout::Direction
+        define_qenum_under<QBoxLayout::Direction>(rb_cQBoxLayout, "Direction");
+        define_qenum_value_under(rb_cQBoxLayoutDirection, "LeftToRight", QBoxLayout::Direction::LeftToRight);
+        define_qenum_value_under(rb_cQBoxLayoutDirection, "RightToLeft", QBoxLayout::Direction::RightToLeft);
+        define_qenum_value_under(rb_cQBoxLayoutDirection, "TopToBottom", QBoxLayout::Direction::TopToBottom);
+        define_qenum_value_under(rb_cQBoxLayoutDirection, "BottomToTop", QBoxLayout::Direction::BottomToTop);
+        define_qenum_value_under(rb_cQBoxLayoutDirection, "Down", QBoxLayout::Direction::Down);
+        define_qenum_value_under(rb_cQBoxLayoutDirection, "Up", QBoxLayout::Direction::Up);
+
+    rb_cQHBoxLayout =
+        // RubyQt6::QtWidgets::QHBoxLayout
+        define_class_under<QHBoxLayout, QBoxLayout>(rb_mQt6QtWidgets, "QHBoxLayout")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QHBoxLayout::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QHBoxLayout>()).define_constructor(Constructor<QHBoxLayout, QWidget *>(), Arg("parent"));
+
+    rb_cQVBoxLayout =
+        // RubyQt6::QtWidgets::QVBoxLayout
+        define_class_under<QVBoxLayout, QBoxLayout>(rb_mQt6QtWidgets, "QVBoxLayout")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QVBoxLayout::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QVBoxLayout>()).define_constructor(Constructor<QVBoxLayout, QWidget *>(), Arg("parent"));
+}

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

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

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

@@ -0,0 +1,90 @@
+#include "qcalendarwidget-rb.hpp"
+#include <qcalendarwidget.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QTextCharFormat>
+
+using namespace Rice;
+
+Rice::Class rb_cQCalendarWidget;
+
+void Init_qcalendarwidget(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQCalendarWidget =
+        // RubyQt6::QtWidgets::QCalendarWidget
+        define_class_under<QCalendarWidget, QWidget>(rb_mQt6QtWidgets, "QCalendarWidget")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QCalendarWidget::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QCalendarWidget, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("calendar", &QCalendarWidget::calendar)
+            .define_method("clear_maximum_date", &QCalendarWidget::clearMaximumDate)
+            .define_method("clear_minimum_date", &QCalendarWidget::clearMinimumDate)
+            .define_method("date_edit_accept_delay", &QCalendarWidget::dateEditAcceptDelay)
+            .define_method<QMap<QDate, QTextCharFormat> (QCalendarWidget::*)() const>("date_text_format", &QCalendarWidget::dateTextFormat)
+            .define_method<QTextCharFormat (QCalendarWidget::*)(QDate) const>("date_text_format", &QCalendarWidget::dateTextFormat, Arg("date"))
+            .define_method("first_day_of_week", &QCalendarWidget::firstDayOfWeek)
+            .define_method("header_text_format", &QCalendarWidget::headerTextFormat)
+            .define_method("horizontal_header_format", &QCalendarWidget::horizontalHeaderFormat)
+            .define_method("date_edit_enabled?", &QCalendarWidget::isDateEditEnabled)
+            .define_method("grid_visible?", &QCalendarWidget::isGridVisible)
+            .define_method("navigation_bar_visible?", &QCalendarWidget::isNavigationBarVisible)
+            .define_method("maximum_date", &QCalendarWidget::maximumDate)
+            .define_method("minimum_date", &QCalendarWidget::minimumDate)
+            .define_method("month_shown", &QCalendarWidget::monthShown)
+            .define_method("selected_date", &QCalendarWidget::selectedDate)
+            .define_method("selection_mode", &QCalendarWidget::selectionMode)
+            .define_method("set_calendar", &QCalendarWidget::setCalendar, Arg("calendar"))
+            .define_method("set_date_edit_accept_delay", &QCalendarWidget::setDateEditAcceptDelay, Arg("delay"))
+            .define_method("set_date_edit_enabled", &QCalendarWidget::setDateEditEnabled, Arg("enable"))
+            .define_method("set_date_text_format", &QCalendarWidget::setDateTextFormat, Arg("date"), Arg("format"))
+            .define_method("set_first_day_of_week", &QCalendarWidget::setFirstDayOfWeek, Arg("day_of_week"))
+            .define_method("set_header_text_format", &QCalendarWidget::setHeaderTextFormat, Arg("format"))
+            .define_method("set_horizontal_header_format", &QCalendarWidget::setHorizontalHeaderFormat, Arg("format"))
+            .define_method("set_maximum_date", &QCalendarWidget::setMaximumDate, Arg("date"))
+            .define_method("set_minimum_date", &QCalendarWidget::setMinimumDate, Arg("date"))
+            .define_method("set_selection_mode", &QCalendarWidget::setSelectionMode, Arg("mode"))
+            .define_method("set_vertical_header_format", &QCalendarWidget::setVerticalHeaderFormat, Arg("format"))
+            .define_method("set_weekday_text_format", &QCalendarWidget::setWeekdayTextFormat, Arg("day_of_week"), Arg("format"))
+            .define_method("vertical_header_format", &QCalendarWidget::verticalHeaderFormat)
+            .define_method("weekday_text_format", &QCalendarWidget::weekdayTextFormat, Arg("day_of_week"))
+            .define_method("year_shown", &QCalendarWidget::yearShown)
+            // Public Slots
+            .define_method("set_current_page", &QCalendarWidget::setCurrentPage, Arg("year"), Arg("month"))
+            .define_method("set_date_range", &QCalendarWidget::setDateRange, Arg("min"), Arg("max"))
+            .define_method("set_grid_visible", &QCalendarWidget::setGridVisible, Arg("show"))
+            .define_method("set_navigation_bar_visible", &QCalendarWidget::setNavigationBarVisible, Arg("visible"))
+            .define_method("set_selected_date", &QCalendarWidget::setSelectedDate, Arg("date"))
+            .define_method("show_next_month", &QCalendarWidget::showNextMonth)
+            .define_method("show_next_year", &QCalendarWidget::showNextYear)
+            .define_method("show_previous_month", &QCalendarWidget::showPreviousMonth)
+            .define_method("show_previous_year", &QCalendarWidget::showPreviousYear)
+            .define_method("show_selected_date", &QCalendarWidget::showSelectedDate)
+            .define_method("show_today", &QCalendarWidget::showToday)
+            // Signals
+            .define_method("activated", &QCalendarWidget::activated, Arg("date"))
+            .define_method("clicked", &QCalendarWidget::clicked, Arg("date"))
+            .define_method("current_page_changed", &QCalendarWidget::currentPageChanged, Arg("year"), Arg("month"))
+            .define_method("selection_changed", &QCalendarWidget::selectionChanged);
+
+    Data_Type<QCalendarWidget::HorizontalHeaderFormat> rb_cQCalendarWidgetHorizontalHeaderFormat =
+        // RubyQt6::QtWidgets::QCalendarWidget::HorizontalHeaderFormat
+        define_qenum_under<QCalendarWidget::HorizontalHeaderFormat>(rb_cQCalendarWidget, "HorizontalHeaderFormat");
+        define_qenum_value_under(rb_cQCalendarWidgetHorizontalHeaderFormat, "NoHorizontalHeader", QCalendarWidget::HorizontalHeaderFormat::NoHorizontalHeader);
+        define_qenum_value_under(rb_cQCalendarWidgetHorizontalHeaderFormat, "SingleLetterDayNames", QCalendarWidget::HorizontalHeaderFormat::SingleLetterDayNames);
+        define_qenum_value_under(rb_cQCalendarWidgetHorizontalHeaderFormat, "ShortDayNames", QCalendarWidget::HorizontalHeaderFormat::ShortDayNames);
+        define_qenum_value_under(rb_cQCalendarWidgetHorizontalHeaderFormat, "LongDayNames", QCalendarWidget::HorizontalHeaderFormat::LongDayNames);
+
+    Data_Type<QCalendarWidget::VerticalHeaderFormat> rb_cQCalendarWidgetVerticalHeaderFormat =
+        // RubyQt6::QtWidgets::QCalendarWidget::VerticalHeaderFormat
+        define_qenum_under<QCalendarWidget::VerticalHeaderFormat>(rb_cQCalendarWidget, "VerticalHeaderFormat");
+        define_qenum_value_under(rb_cQCalendarWidgetVerticalHeaderFormat, "NoVerticalHeader", QCalendarWidget::VerticalHeaderFormat::NoVerticalHeader);
+        define_qenum_value_under(rb_cQCalendarWidgetVerticalHeaderFormat, "ISOWeekNumbers", QCalendarWidget::VerticalHeaderFormat::ISOWeekNumbers);
+
+    Data_Type<QCalendarWidget::SelectionMode> rb_cQCalendarWidgetSelectionMode =
+        // RubyQt6::QtWidgets::QCalendarWidget::SelectionMode
+        define_qenum_under<QCalendarWidget::SelectionMode>(rb_cQCalendarWidget, "SelectionMode");
+        define_qenum_value_under(rb_cQCalendarWidgetSelectionMode, "NoSelection", QCalendarWidget::SelectionMode::NoSelection);
+        define_qenum_value_under(rb_cQCalendarWidgetSelectionMode, "SingleSelection", QCalendarWidget::SelectionMode::SingleSelection);
+}

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

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

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

@@ -0,0 +1,24 @@
+#include "qcheckbox-rb.hpp"
+#include <qcheckbox.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQCheckBox;
+
+void Init_qcheckbox(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQCheckBox =
+        // RubyQt6::QtWidgets::QCheckBox
+        define_class_under<QCheckBox, QAbstractButton>(rb_mQt6QtWidgets, "QCheckBox")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QCheckBox::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QCheckBox, const QString &, QWidget *>(), Arg("text"), Arg("parent"))
+            // Public Functions
+            .define_method("check_state", &QCheckBox::checkState)
+            .define_method("tristate?", &QCheckBox::isTristate)
+            .define_method("set_check_state", &QCheckBox::setCheckState, Arg("state"))
+            .define_method("set_tristate", &QCheckBox::setTristate, Arg("y") = static_cast<bool>(true))
+            // Signals
+            .define_method("check_state_changed", &QCheckBox::checkStateChanged, Arg("state"));
+}

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

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

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

@@ -0,0 +1,51 @@
+#include "qcolordialog-rb.hpp"
+#include <qcolordialog.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQColorDialog;
+
+void Init_qcolordialog(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQColorDialog =
+        // RubyQt6::QtWidgets::QColorDialog
+        define_class_under<QColorDialog, QDialog>(rb_mQt6QtWidgets, "QColorDialog")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QColorDialog::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QColorDialog, const QColor &, QWidget *>(), Arg("initial"), Arg("parent"))
+            // Public Functions
+            .define_method("current_color", &QColorDialog::currentColor)
+            .define_method<void (QColorDialog::*)(QObject *, const char *)>("open", &QColorDialog::open, Arg("receiver"), Arg("member"))
+            .define_method("options", &QColorDialog::options)
+            .define_method("selected_color", &QColorDialog::selectedColor)
+            .define_method("set_current_color", &QColorDialog::setCurrentColor, Arg("color"))
+            .define_method("set_option", &QColorDialog::setOption, Arg("option"), Arg("on") = static_cast<bool>(true))
+            .define_method("set_options", &QColorDialog::setOptions, Arg("options"))
+            .define_method("set_visible", &QColorDialog::setVisible, Arg("visible"))
+            .define_method("test_option", &QColorDialog::testOption, Arg("option"))
+            // Signals
+            .define_method("color_selected", &QColorDialog::colorSelected, Arg("color"))
+            .define_method("current_color_changed", &QColorDialog::currentColorChanged, Arg("color"))
+            // Static Public Members
+            .define_singleton_function("custom_color", &QColorDialog::customColor, Arg("index"))
+            .define_singleton_function("custom_count", &QColorDialog::customCount)
+            .define_singleton_function("get_color", &QColorDialog::getColor, Arg("initial") = static_cast<const QColor &>(Qt::white), Arg("parent") = static_cast<QWidget *>(nullptr), Arg("title") = static_cast<const QString &>(QString()), Arg("options") = static_cast<QColorDialog::ColorDialogOptions>(QColorDialog::ColorDialogOptions()))
+            .define_singleton_function("set_custom_color", &QColorDialog::setCustomColor, Arg("index"), Arg("color"))
+            .define_singleton_function("set_standard_color", &QColorDialog::setStandardColor, Arg("index"), Arg("color"))
+            .define_singleton_function("standard_color", &QColorDialog::standardColor, Arg("index"));
+
+    Data_Type<QColorDialog::ColorDialogOption> rb_cQColorDialogColorDialogOption =
+        // RubyQt6::QtWidgets::QColorDialog::ColorDialogOption
+        define_qenum_under<QColorDialog::ColorDialogOption>(rb_cQColorDialog, "ColorDialogOption");
+        define_qenum_value_under(rb_cQColorDialogColorDialogOption, "ShowAlphaChannel", QColorDialog::ColorDialogOption::ShowAlphaChannel);
+        define_qenum_value_under(rb_cQColorDialogColorDialogOption, "NoButtons", QColorDialog::ColorDialogOption::NoButtons);
+        define_qenum_value_under(rb_cQColorDialogColorDialogOption, "DontUseNativeDialog", QColorDialog::ColorDialogOption::DontUseNativeDialog);
+        define_qenum_value_under(rb_cQColorDialogColorDialogOption, "NoEyeDropperButton", QColorDialog::ColorDialogOption::NoEyeDropperButton);
+
+    Data_Type<QFlags<QColorDialog::ColorDialogOption>> rb_cQColorDialogColorDialogOptions =
+        // RubyQt6::QtWidgets::QColorDialog::ColorDialogOptions
+        define_qflags_under<QColorDialog::ColorDialogOption>(rb_cQColorDialog, "ColorDialogOptions");
+}

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

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

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

@@ -0,0 +1,33 @@
+#include "qcolumnview-rb.hpp"
+#include <qcolumnview.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQColumnView;
+
+void Init_qcolumnview(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQColumnView =
+        // RubyQt6::QtWidgets::QColumnView
+        define_class_under<QColumnView, QAbstractItemView>(rb_mQt6QtWidgets, "QColumnView")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QColumnView::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QColumnView, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("column_widths", &QColumnView::columnWidths)
+            .define_method("index_at", &QColumnView::indexAt, Arg("point"))
+            .define_method("preview_widget", &QColumnView::previewWidget)
+            .define_method("resize_grips_visible", &QColumnView::resizeGripsVisible)
+            .define_method("scroll_to", &QColumnView::scrollTo, Arg("index"), Arg("hint") = static_cast<QAbstractItemView::ScrollHint>(QAbstractItemView::ScrollHint::EnsureVisible))
+            .define_method("select_all", &QColumnView::selectAll)
+            .define_method("set_column_widths", &QColumnView::setColumnWidths, Arg("list"))
+            .define_method("set_model", &QColumnView::setModel, Arg("model"))
+            .define_method("set_preview_widget", &QColumnView::setPreviewWidget, Arg("widget"))
+            .define_method("set_resize_grips_visible", &QColumnView::setResizeGripsVisible, Arg("visible"))
+            .define_method("set_root_index", &QColumnView::setRootIndex, Arg("index"))
+            .define_method("set_selection_model", &QColumnView::setSelectionModel, Arg("selection_model"))
+            .define_method("visual_rect", &QColumnView::visualRect, Arg("index"))
+            // Signals
+            .define_method("update_preview_widget", &QColumnView::updatePreviewWidget, Arg("index"));
+}

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

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

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

@@ -0,0 +1,121 @@
+#include "qcombobox-rb.hpp"
+#include <qcombobox.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QAbstractItemView>
+#include <QCompleter>
+#include <QLineEdit>
+
+using namespace Rice;
+
+Rice::Class rb_cQComboBox;
+
+void Init_qcombobox(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQComboBox =
+        // RubyQt6::QtWidgets::QComboBox
+        define_class_under<QComboBox, QWidget>(rb_mQt6QtWidgets, "QComboBox")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QComboBox::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QComboBox, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method<void (QComboBox::*)(const QString &, const QVariant &)>("_add_item", &QComboBox::addItem, Arg("text"), Arg("user_data") = static_cast<const QVariant &>(QVariant()))
+            .define_method<void (QComboBox::*)(const QIcon &, const QString &, const QVariant &)>("_add_item", &QComboBox::addItem, Arg("icon"), Arg("text"), Arg("user_data") = static_cast<const QVariant &>(QVariant()))
+            .define_method("add_items", &QComboBox::addItems, Arg("texts"))
+            .define_method("completer", &QComboBox::completer)
+            .define_method("count", &QComboBox::count)
+            .define_method("current_data", &QComboBox::currentData, Arg("role") = static_cast<int>(Qt::UserRole))
+            .define_method("current_index", &QComboBox::currentIndex)
+            .define_method("current_text", &QComboBox::currentText)
+            .define_method("duplicates_enabled", &QComboBox::duplicatesEnabled)
+            .define_method("find_data", &QComboBox::findData, Arg("data"), Arg("role") = static_cast<int>(Qt::UserRole), Arg("flags") = static_cast<Qt::MatchFlags>(static_cast<Qt::MatchFlags>(Qt::MatchExactly | Qt::MatchCaseSensitive)))
+            .define_method("find_text", &QComboBox::findText, Arg("text"), Arg("flags") = static_cast<Qt::MatchFlags>(static_cast<Qt::MatchFlags>(Qt::MatchExactly | Qt::MatchCaseSensitive)))
+            .define_method("has_frame", &QComboBox::hasFrame)
+            .define_method("hide_popup", &QComboBox::hidePopup)
+            .define_method("icon_size", &QComboBox::iconSize)
+            .define_method<void (QComboBox::*)(int, const QIcon &, const QString &, const QVariant &)>("insert_item", &QComboBox::insertItem, Arg("index"), Arg("icon"), Arg("text"), Arg("user_data") = static_cast<const QVariant &>(QVariant()))
+            .define_method<void (QComboBox::*)(int, const QString &, const QVariant &)>("insert_item", &QComboBox::insertItem, Arg("index"), Arg("text"), Arg("user_data") = static_cast<const QVariant &>(QVariant()))
+            .define_method("insert_items", &QComboBox::insertItems, Arg("index"), Arg("texts"))
+            .define_method("insert_policy", &QComboBox::insertPolicy)
+            .define_method("insert_separator", &QComboBox::insertSeparator, Arg("index"))
+            .define_method("editable?", &QComboBox::isEditable)
+            .define_method("item_data", &QComboBox::itemData, Arg("index"), Arg("role") = static_cast<int>(Qt::UserRole))
+            .define_method("item_delegate", &QComboBox::itemDelegate)
+            .define_method("item_icon", &QComboBox::itemIcon, Arg("index"))
+            .define_method("item_text", &QComboBox::itemText, Arg("index"))
+            .define_method("label_drawing_mode", &QComboBox::labelDrawingMode)
+            .define_method("line_edit", &QComboBox::lineEdit)
+            .define_method("max_count", &QComboBox::maxCount)
+            .define_method("max_visible_items", &QComboBox::maxVisibleItems)
+            .define_method("minimum_contents_length", &QComboBox::minimumContentsLength)
+            .define_method("model", &QComboBox::model)
+            .define_method("model_column", &QComboBox::modelColumn)
+            .define_method("placeholder_text", &QComboBox::placeholderText)
+            .define_method("remove_item", &QComboBox::removeItem, Arg("index"))
+            .define_method("root_model_index", &QComboBox::rootModelIndex)
+            .define_method("set_completer", &QComboBox::setCompleter, Arg("c"))
+            .define_method("set_duplicates_enabled", &QComboBox::setDuplicatesEnabled, Arg("enable"))
+            .define_method("set_editable", &QComboBox::setEditable, Arg("editable"))
+            .define_method("set_frame", &QComboBox::setFrame, Arg("enable"))
+            .define_method("set_icon_size", &QComboBox::setIconSize, Arg("size"))
+            .define_method("set_insert_policy", &QComboBox::setInsertPolicy, Arg("policy"))
+            .define_method("set_item_data", &QComboBox::setItemData, Arg("index"), Arg("value"), Arg("role") = static_cast<int>(Qt::UserRole))
+            .define_method("set_item_delegate", &QComboBox::setItemDelegate, Arg("delegate"))
+            .define_method("set_item_icon", &QComboBox::setItemIcon, Arg("index"), Arg("icon"))
+            .define_method("set_item_text", &QComboBox::setItemText, Arg("index"), Arg("text"))
+            .define_method("set_label_drawing_mode", &QComboBox::setLabelDrawingMode, Arg("label_drawing"))
+            .define_method("set_line_edit", &QComboBox::setLineEdit, Arg("edit"))
+            .define_method("set_max_count", &QComboBox::setMaxCount, Arg("max"))
+            .define_method("set_max_visible_items", &QComboBox::setMaxVisibleItems, Arg("max_items"))
+            .define_method("set_minimum_contents_length", &QComboBox::setMinimumContentsLength, Arg("characters"))
+            .define_method("set_model", &QComboBox::setModel, Arg("model"))
+            .define_method("set_model_column", &QComboBox::setModelColumn, Arg("visible_column"))
+            .define_method("set_placeholder_text", &QComboBox::setPlaceholderText, Arg("placeholder_text"))
+            .define_method("set_root_model_index", &QComboBox::setRootModelIndex, Arg("index"))
+            .define_method("set_size_adjust_policy", &QComboBox::setSizeAdjustPolicy, Arg("policy"))
+            .define_method("set_validator", &QComboBox::setValidator, Arg("v"))
+            .define_method("set_view", &QComboBox::setView, Arg("item_view"))
+            .define_method("show_popup", &QComboBox::showPopup)
+            .define_method("size_adjust_policy", &QComboBox::sizeAdjustPolicy)
+            .define_method("validator", &QComboBox::validator)
+            .define_method("view", &QComboBox::view)
+            // Public Slots
+            .define_method("clear", &QComboBox::clear)
+            .define_method("clear_edit_text", &QComboBox::clearEditText)
+            .define_method("set_current_index", &QComboBox::setCurrentIndex, Arg("index"))
+            .define_method("set_current_text", &QComboBox::setCurrentText, Arg("text"))
+            .define_method("set_edit_text", &QComboBox::setEditText, Arg("text"))
+            // Signals
+            .define_method("activated", &QComboBox::activated, Arg("index"))
+            .define_method("current_index_changed", &QComboBox::currentIndexChanged, Arg("index"))
+            .define_method("current_text_changed", &QComboBox::currentTextChanged, Arg("text"))
+            .define_method("edit_text_changed", &QComboBox::editTextChanged, Arg("text"))
+            .define_method("highlighted", &QComboBox::highlighted, Arg("index"))
+            .define_method("text_activated", &QComboBox::textActivated, Arg("text"))
+            .define_method("text_highlighted", &QComboBox::textHighlighted, Arg("text"));
+
+    Data_Type<QComboBox::InsertPolicy> rb_cQComboBoxInsertPolicy =
+        // RubyQt6::QtWidgets::QComboBox::InsertPolicy
+        define_qenum_under<QComboBox::InsertPolicy>(rb_cQComboBox, "InsertPolicy");
+        define_qenum_value_under(rb_cQComboBoxInsertPolicy, "NoInsert", QComboBox::InsertPolicy::NoInsert);
+        define_qenum_value_under(rb_cQComboBoxInsertPolicy, "InsertAtTop", QComboBox::InsertPolicy::InsertAtTop);
+        define_qenum_value_under(rb_cQComboBoxInsertPolicy, "InsertAtCurrent", QComboBox::InsertPolicy::InsertAtCurrent);
+        define_qenum_value_under(rb_cQComboBoxInsertPolicy, "InsertAtBottom", QComboBox::InsertPolicy::InsertAtBottom);
+        define_qenum_value_under(rb_cQComboBoxInsertPolicy, "InsertAfterCurrent", QComboBox::InsertPolicy::InsertAfterCurrent);
+        define_qenum_value_under(rb_cQComboBoxInsertPolicy, "InsertBeforeCurrent", QComboBox::InsertPolicy::InsertBeforeCurrent);
+        define_qenum_value_under(rb_cQComboBoxInsertPolicy, "InsertAlphabetically", QComboBox::InsertPolicy::InsertAlphabetically);
+
+    Data_Type<QComboBox::LabelDrawingMode> rb_cQComboBoxLabelDrawingMode =
+        // RubyQt6::QtWidgets::QComboBox::LabelDrawingMode
+        define_qenum_under<QComboBox::LabelDrawingMode>(rb_cQComboBox, "LabelDrawingMode");
+        define_qenum_value_under(rb_cQComboBoxLabelDrawingMode, "UseStyle", QComboBox::LabelDrawingMode::UseStyle);
+        define_qenum_value_under(rb_cQComboBoxLabelDrawingMode, "UseDelegate", QComboBox::LabelDrawingMode::UseDelegate);
+
+    Data_Type<QComboBox::SizeAdjustPolicy> rb_cQComboBoxSizeAdjustPolicy =
+        // RubyQt6::QtWidgets::QComboBox::SizeAdjustPolicy
+        define_qenum_under<QComboBox::SizeAdjustPolicy>(rb_cQComboBox, "SizeAdjustPolicy");
+        define_qenum_value_under(rb_cQComboBoxSizeAdjustPolicy, "AdjustToContents", QComboBox::SizeAdjustPolicy::AdjustToContents);
+        define_qenum_value_under(rb_cQComboBoxSizeAdjustPolicy, "AdjustToContentsOnFirstShow", QComboBox::SizeAdjustPolicy::AdjustToContentsOnFirstShow);
+        define_qenum_value_under(rb_cQComboBoxSizeAdjustPolicy, "AdjustToMinimumContentsLengthWithIcon", QComboBox::SizeAdjustPolicy::AdjustToMinimumContentsLengthWithIcon);
+}

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

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

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

@@ -0,0 +1,23 @@
+#include "qcommandlinkbutton-rb.hpp"
+#include <qcommandlinkbutton.h>
+
+#include <QStyleOptionButton>
+
+using namespace Rice;
+
+Rice::Class rb_cQCommandLinkButton;
+
+void Init_qcommandlinkbutton(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQCommandLinkButton =
+        // RubyQt6::QtWidgets::QCommandLinkButton
+        define_class_under<QCommandLinkButton, QPushButton>(rb_mQt6QtWidgets, "QCommandLinkButton")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QCommandLinkButton::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QCommandLinkButton, const QString &, const QString &, QWidget *>(), Arg("text"), Arg("description"), Arg("parent"))
+            // Public Functions
+            .define_method("description", &QCommandLinkButton::description)
+            .define_method("init_style_option", &QCommandLinkButton::initStyleOption, Arg("option"))
+            .define_method("set_description", &QCommandLinkButton::setDescription, Arg("description"));
+}

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

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

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

@@ -0,0 +1,116 @@
+#include "qdatetimeedit-rb.hpp"
+#include <qdatetimeedit.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QCalendarWidget>
+
+using namespace Rice;
+
+Rice::Class rb_cQDateTimeEdit;
+Rice::Class rb_cQDateEdit;
+Rice::Class rb_cQTimeEdit;
+
+void Init_qdatetimeedit(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQDateTimeEdit =
+        // RubyQt6::QtWidgets::QDateTimeEdit
+        define_class_under<QDateTimeEdit, QAbstractSpinBox>(rb_mQt6QtWidgets, "QDateTimeEdit")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QDateTimeEdit::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QDateTimeEdit, const QDateTime &, QWidget *>(), Arg("datetime"), Arg("parent"))
+            // Public Functions
+            .define_method("calendar", &QDateTimeEdit::calendar)
+            .define_method("calendar_popup", &QDateTimeEdit::calendarPopup)
+            .define_method("calendar_widget", &QDateTimeEdit::calendarWidget)
+            .define_method("clear", &QDateTimeEdit::clear)
+            .define_method("clear_maximum_date", &QDateTimeEdit::clearMaximumDate)
+            .define_method("clear_maximum_date_time", &QDateTimeEdit::clearMaximumDateTime)
+            .define_method("clear_maximum_time", &QDateTimeEdit::clearMaximumTime)
+            .define_method("clear_minimum_date", &QDateTimeEdit::clearMinimumDate)
+            .define_method("clear_minimum_date_time", &QDateTimeEdit::clearMinimumDateTime)
+            .define_method("clear_minimum_time", &QDateTimeEdit::clearMinimumTime)
+            .define_method("current_section", &QDateTimeEdit::currentSection)
+            .define_method("current_section_index", &QDateTimeEdit::currentSectionIndex)
+            .define_method("date", &QDateTimeEdit::date)
+            .define_method("date_time", &QDateTimeEdit::dateTime)
+            .define_method("display_format", &QDateTimeEdit::displayFormat)
+            .define_method("displayed_sections", &QDateTimeEdit::displayedSections)
+            .define_method("maximum_date", &QDateTimeEdit::maximumDate)
+            .define_method("maximum_date_time", &QDateTimeEdit::maximumDateTime)
+            .define_method("maximum_time", &QDateTimeEdit::maximumTime)
+            .define_method("minimum_date", &QDateTimeEdit::minimumDate)
+            .define_method("minimum_date_time", &QDateTimeEdit::minimumDateTime)
+            .define_method("minimum_time", &QDateTimeEdit::minimumTime)
+            .define_method("section_at", &QDateTimeEdit::sectionAt, Arg("index"))
+            .define_method("section_count", &QDateTimeEdit::sectionCount)
+            .define_method("section_text", &QDateTimeEdit::sectionText, Arg("section"))
+            .define_method("set_calendar", &QDateTimeEdit::setCalendar, Arg("calendar"))
+            .define_method("set_calendar_popup", &QDateTimeEdit::setCalendarPopup, Arg("enable"))
+            .define_method("set_calendar_widget", &QDateTimeEdit::setCalendarWidget, Arg("calendar_widget"))
+            .define_method("set_current_section", &QDateTimeEdit::setCurrentSection, Arg("section"))
+            .define_method("set_current_section_index", &QDateTimeEdit::setCurrentSectionIndex, Arg("index"))
+            .define_method("set_date_range", &QDateTimeEdit::setDateRange, Arg("min"), Arg("max"))
+            .define_method("set_date_time_range", &QDateTimeEdit::setDateTimeRange, Arg("min"), Arg("max"))
+            .define_method("set_display_format", &QDateTimeEdit::setDisplayFormat, Arg("format"))
+            .define_method("set_maximum_date", &QDateTimeEdit::setMaximumDate, Arg("max"))
+            .define_method("set_maximum_date_time", &QDateTimeEdit::setMaximumDateTime, Arg("dt"))
+            .define_method("set_maximum_time", &QDateTimeEdit::setMaximumTime, Arg("max"))
+            .define_method("set_minimum_date", &QDateTimeEdit::setMinimumDate, Arg("min"))
+            .define_method("set_minimum_date_time", &QDateTimeEdit::setMinimumDateTime, Arg("dt"))
+            .define_method("set_minimum_time", &QDateTimeEdit::setMinimumTime, Arg("min"))
+            .define_method("set_selected_section", &QDateTimeEdit::setSelectedSection, Arg("section"))
+            .define_method("set_time_range", &QDateTimeEdit::setTimeRange, Arg("min"), Arg("max"))
+            .define_method("set_time_zone", &QDateTimeEdit::setTimeZone, Arg("zone"))
+            .define_method("step_by", &QDateTimeEdit::stepBy, Arg("steps"))
+            .define_method("time", &QDateTimeEdit::time)
+            .define_method("time_zone", &QDateTimeEdit::timeZone)
+            // Public Slots
+            .define_method("set_date", &QDateTimeEdit::setDate, Arg("date"))
+            .define_method("set_date_time", &QDateTimeEdit::setDateTime, Arg("date_time"))
+            .define_method("set_time", &QDateTimeEdit::setTime, Arg("time"))
+            // Signals
+            .define_method("date_changed", &QDateTimeEdit::dateChanged, Arg("date"))
+            .define_method("date_time_changed", &QDateTimeEdit::dateTimeChanged, Arg("date_time"))
+            .define_method("time_changed", &QDateTimeEdit::timeChanged, Arg("time"));
+
+    Data_Type<QDateTimeEdit::Section> rb_cQDateTimeEditSection =
+        // RubyQt6::QtWidgets::QDateTimeEdit::Section
+        define_qenum_under<QDateTimeEdit::Section>(rb_cQDateTimeEdit, "Section");
+        define_qenum_value_under(rb_cQDateTimeEditSection, "NoSection", QDateTimeEdit::Section::NoSection);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "AmPmSection", QDateTimeEdit::Section::AmPmSection);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "MSecSection", QDateTimeEdit::Section::MSecSection);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "SecondSection", QDateTimeEdit::Section::SecondSection);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "MinuteSection", QDateTimeEdit::Section::MinuteSection);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "HourSection", QDateTimeEdit::Section::HourSection);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "DaySection", QDateTimeEdit::Section::DaySection);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "MonthSection", QDateTimeEdit::Section::MonthSection);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "YearSection", QDateTimeEdit::Section::YearSection);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "TimeSections_Mask", QDateTimeEdit::Section::TimeSections_Mask);
+        define_qenum_value_under(rb_cQDateTimeEditSection, "DateSections_Mask", QDateTimeEdit::Section::DateSections_Mask);
+
+    Data_Type<QFlags<QDateTimeEdit::Section>> rb_cQDateTimeEditSections =
+        // RubyQt6::QtWidgets::QDateTimeEdit::Sections
+        define_qflags_under<QDateTimeEdit::Section>(rb_cQDateTimeEdit, "Sections");
+
+    rb_cQDateEdit =
+        // RubyQt6::QtWidgets::QDateEdit
+        define_class_under<QDateEdit, QDateTimeEdit>(rb_mQt6QtWidgets, "QDateEdit")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QDateEdit::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QDateEdit, QDate, QWidget *>(), Arg("date"), Arg("parent"))
+            // Signals
+            .define_method("user_date_changed", &QDateEdit::userDateChanged, Arg("date"));
+
+    rb_cQTimeEdit =
+        // RubyQt6::QtWidgets::QTimeEdit
+        define_class_under<QTimeEdit, QDateTimeEdit>(rb_mQt6QtWidgets, "QTimeEdit")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QTimeEdit::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QTimeEdit, QTime, QWidget *>(), Arg("time"), Arg("parent"))
+            // Signals
+            .define_method("user_time_changed", &QTimeEdit::userTimeChanged, Arg("time"));
+}

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

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