ruby-qt6-qtwidgets 1.0.0

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

@@ -0,0 +1,109 @@
+#include "qlineedit-rb.hpp"
+#include <qlineedit.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QCompleter>
+#include <QMenu>
+#include <QValidator>
+
+using namespace Rice;
+
+Rice::Class rb_cQLineEdit;
+
+void Init_qlineedit(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQLineEdit =
+        // RubyQt6::QtWidgets::QLineEdit
+        define_class_under<QLineEdit, QWidget>(rb_mQt6QtWidgets, "QLineEdit")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QLineEdit::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QLineEdit, const QString &, QWidget *>(), Arg("contents"), Arg("parent"))
+            // Public Functions
+            .define_method<QAction *(QLineEdit::*)(const QIcon &, QLineEdit::ActionPosition)>("add_action", &QLineEdit::addAction, Arg("icon"), Arg("position"))
+            .define_method<void (QLineEdit::*)(QAction *, QLineEdit::ActionPosition)>("add_action", &QLineEdit::addAction, Arg("action"), Arg("position"))
+            .define_method("alignment", &QLineEdit::alignment)
+            .define_method("backspace", &QLineEdit::backspace)
+            .define_method("completer", &QLineEdit::completer)
+            .define_method("create_standard_context_menu", &QLineEdit::createStandardContextMenu)
+            .define_method("cursor_backward", &QLineEdit::cursorBackward, Arg("mark"), Arg("steps") = static_cast<int>(1))
+            .define_method("cursor_forward", &QLineEdit::cursorForward, Arg("mark"), Arg("steps") = static_cast<int>(1))
+            .define_method("cursor_move_style", &QLineEdit::cursorMoveStyle)
+            .define_method("cursor_position", &QLineEdit::cursorPosition)
+            .define_method("cursor_position_at", &QLineEdit::cursorPositionAt, Arg("pos"))
+            .define_method("cursor_word_backward", &QLineEdit::cursorWordBackward, Arg("mark"))
+            .define_method("cursor_word_forward", &QLineEdit::cursorWordForward, Arg("mark"))
+            .define_method("del", &QLineEdit::del)
+            .define_method("deselect", &QLineEdit::deselect)
+            .define_method("display_text", &QLineEdit::displayText)
+            .define_method("drag_enabled", &QLineEdit::dragEnabled)
+            .define_method("echo_mode", &QLineEdit::echoMode)
+            .define_method("has_acceptable_input", &QLineEdit::hasAcceptableInput)
+            .define_method("has_frame", &QLineEdit::hasFrame)
+            .define_method("has_selected_text", &QLineEdit::hasSelectedText)
+            .define_method("home", &QLineEdit::home, Arg("mark"))
+            .define_method("input_mask", &QLineEdit::inputMask)
+            .define_method("insert", &QLineEdit::insert, Arg("new_text"))
+            .define_method("clear_button_enabled?", &QLineEdit::isClearButtonEnabled)
+            .define_method("modified?", &QLineEdit::isModified)
+            .define_method("read_only?", &QLineEdit::isReadOnly)
+            .define_method("redo_available?", &QLineEdit::isRedoAvailable)
+            .define_method("undo_available?", &QLineEdit::isUndoAvailable)
+            .define_method("max_length", &QLineEdit::maxLength)
+            .define_method("placeholder_text", &QLineEdit::placeholderText)
+            .define_method("selected_text", &QLineEdit::selectedText)
+            .define_method("selection_end", &QLineEdit::selectionEnd)
+            .define_method("selection_length", &QLineEdit::selectionLength)
+            .define_method("selection_start", &QLineEdit::selectionStart)
+            .define_method("_set_alignment", &QLineEdit::setAlignment, Arg("alignment"))
+            .define_method("set_clear_button_enabled", &QLineEdit::setClearButtonEnabled, Arg("enable"))
+            .define_method("set_completer", &QLineEdit::setCompleter, Arg("completer"))
+            .define_method("set_cursor_move_style", &QLineEdit::setCursorMoveStyle, Arg("style"))
+            .define_method("set_cursor_position", &QLineEdit::setCursorPosition, Arg("position"))
+            .define_method("set_drag_enabled", &QLineEdit::setDragEnabled, Arg("b"))
+            .define_method("set_echo_mode", &QLineEdit::setEchoMode, Arg("mode"))
+            .define_method("set_frame", &QLineEdit::setFrame, Arg("enable"))
+            .define_method("_set_input_mask", &QLineEdit::setInputMask, Arg("input_mask"))
+            .define_method("set_max_length", &QLineEdit::setMaxLength, Arg("length"))
+            .define_method("set_modified", &QLineEdit::setModified, Arg("modified"))
+            .define_method("set_placeholder_text", &QLineEdit::setPlaceholderText, Arg("placeholder"))
+            .define_method("set_read_only", &QLineEdit::setReadOnly, Arg("enable"))
+            .define_method("set_selection", &QLineEdit::setSelection, Arg("start"), Arg("length"))
+            .define_method<void (QLineEdit::*)(const QMargins &)>("set_text_margins", &QLineEdit::setTextMargins, Arg("margins"))
+            .define_method<void (QLineEdit::*)(int, int, int, int)>("set_text_margins", &QLineEdit::setTextMargins, Arg("left"), Arg("top"), Arg("right"), Arg("bottom"))
+            .define_method("set_validator", &QLineEdit::setValidator, Arg("validator"))
+            .define_method("text", &QLineEdit::text)
+            .define_method("text_margins", &QLineEdit::textMargins)
+            .define_method("validator", &QLineEdit::validator)
+            // Public Slots
+            .define_method("clear", &QLineEdit::clear)
+            .define_method("copy", &QLineEdit::copy)
+            .define_method("cut", &QLineEdit::cut)
+            .define_method("paste", &QLineEdit::paste)
+            .define_method("redo", &QLineEdit::redo)
+            .define_method("select_all", &QLineEdit::selectAll)
+            .define_method("_set_text", &QLineEdit::setText, Arg("text"))
+            .define_method("undo", &QLineEdit::undo)
+            // Signals
+            .define_method("cursor_position_changed", &QLineEdit::cursorPositionChanged, Arg("old"), Arg("new"))
+            .define_method("editing_finished", &QLineEdit::editingFinished)
+            .define_method("input_rejected", &QLineEdit::inputRejected)
+            .define_method("return_pressed", &QLineEdit::returnPressed)
+            .define_method("selection_changed", &QLineEdit::selectionChanged)
+            .define_method("text_changed", &QLineEdit::textChanged, Arg("text"))
+            .define_method("text_edited", &QLineEdit::textEdited, Arg("text"));
+
+    Data_Type<QLineEdit::ActionPosition> rb_cQLineEditActionPosition =
+        // RubyQt6::QtWidgets::QLineEdit::ActionPosition
+        define_qenum_under<QLineEdit::ActionPosition>(rb_cQLineEdit, "ActionPosition");
+        define_qenum_value_under(rb_cQLineEditActionPosition, "LeadingPosition", QLineEdit::ActionPosition::LeadingPosition);
+        define_qenum_value_under(rb_cQLineEditActionPosition, "TrailingPosition", QLineEdit::ActionPosition::TrailingPosition);
+
+    Data_Type<QLineEdit::EchoMode> rb_cQLineEditEchoMode =
+        // RubyQt6::QtWidgets::QLineEdit::EchoMode
+        define_qenum_under<QLineEdit::EchoMode>(rb_cQLineEdit, "EchoMode");
+        define_qenum_value_under(rb_cQLineEditEchoMode, "Normal", QLineEdit::EchoMode::Normal);
+        define_qenum_value_under(rb_cQLineEditEchoMode, "NoEcho", QLineEdit::EchoMode::NoEcho);
+        define_qenum_value_under(rb_cQLineEditEchoMode, "Password", QLineEdit::EchoMode::Password);
+        define_qenum_value_under(rb_cQLineEditEchoMode, "PasswordEchoOnEdit", QLineEdit::EchoMode::PasswordEchoOnEdit);
+}

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

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

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

@@ -0,0 +1,89 @@
+#include "qlistview-rb.hpp"
+#include <qlistview.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQListView;
+
+void Init_qlistview(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQListView =
+        // RubyQt6::QtWidgets::QListView
+        define_class_under<QListView, QAbstractItemView>(rb_mQt6QtWidgets, "QListView")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QListView::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QListView, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("batch_size", &QListView::batchSize)
+            .define_method("clear_property_flags", &QListView::clearPropertyFlags)
+            .define_method("do_items_layout", &QListView::doItemsLayout)
+            .define_method("flow", &QListView::flow)
+            .define_method("grid_size", &QListView::gridSize)
+            .define_method("index_at", &QListView::indexAt, Arg("p"))
+            .define_method("row_hidden?", &QListView::isRowHidden, Arg("row"))
+            .define_method("selection_rect_visible?", &QListView::isSelectionRectVisible)
+            .define_method("wrapping?", &QListView::isWrapping)
+            .define_method("item_alignment", &QListView::itemAlignment)
+            .define_method("layout_mode", &QListView::layoutMode)
+            .define_method("model_column", &QListView::modelColumn)
+            .define_method("movement", &QListView::movement)
+            .define_method("reset", &QListView::reset)
+            .define_method("resize_mode", &QListView::resizeMode)
+            .define_method("scroll_to", &QListView::scrollTo, Arg("index"), Arg("hint") = static_cast<QAbstractItemView::ScrollHint>(QAbstractItemView::ScrollHint::EnsureVisible))
+            .define_method("set_batch_size", &QListView::setBatchSize, Arg("batch_size"))
+            .define_method("set_flow", &QListView::setFlow, Arg("flow"))
+            .define_method("set_grid_size", &QListView::setGridSize, Arg("size"))
+            .define_method("set_item_alignment", &QListView::setItemAlignment, Arg("alignment"))
+            .define_method("set_layout_mode", &QListView::setLayoutMode, Arg("mode"))
+            .define_method("set_model_column", &QListView::setModelColumn, Arg("column"))
+            .define_method("set_movement", &QListView::setMovement, Arg("movement"))
+            .define_method("set_resize_mode", &QListView::setResizeMode, Arg("mode"))
+            .define_method("set_root_index", &QListView::setRootIndex, Arg("index"))
+            .define_method("set_row_hidden", &QListView::setRowHidden, Arg("row"), Arg("hide"))
+            .define_method("set_selection_rect_visible", &QListView::setSelectionRectVisible, Arg("show"))
+            .define_method("set_spacing", &QListView::setSpacing, Arg("space"))
+            .define_method("set_uniform_item_sizes", &QListView::setUniformItemSizes, Arg("enable"))
+            .define_method("set_view_mode", &QListView::setViewMode, Arg("mode"))
+            .define_method("set_word_wrap", &QListView::setWordWrap, Arg("on"))
+            .define_method("set_wrapping", &QListView::setWrapping, Arg("enable"))
+            .define_method("spacing", &QListView::spacing)
+            .define_method("uniform_item_sizes", &QListView::uniformItemSizes)
+            .define_method("view_mode", &QListView::viewMode)
+            .define_method("visual_rect", &QListView::visualRect, Arg("index"))
+            .define_method("word_wrap", &QListView::wordWrap)
+            // Signals
+            .define_method("indexes_moved", &QListView::indexesMoved, Arg("indexes"));
+
+    Data_Type<QListView::Flow> rb_cQListViewFlow =
+        // RubyQt6::QtWidgets::QListView::Flow
+        define_qenum_under<QListView::Flow>(rb_cQListView, "Flow");
+        define_qenum_value_under(rb_cQListViewFlow, "LeftToRight", QListView::Flow::LeftToRight);
+        define_qenum_value_under(rb_cQListViewFlow, "TopToBottom", QListView::Flow::TopToBottom);
+
+    Data_Type<QListView::LayoutMode> rb_cQListViewLayoutMode =
+        // RubyQt6::QtWidgets::QListView::LayoutMode
+        define_qenum_under<QListView::LayoutMode>(rb_cQListView, "LayoutMode");
+        define_qenum_value_under(rb_cQListViewLayoutMode, "SinglePass", QListView::LayoutMode::SinglePass);
+        define_qenum_value_under(rb_cQListViewLayoutMode, "Batched", QListView::LayoutMode::Batched);
+
+    Data_Type<QListView::Movement> rb_cQListViewMovement =
+        // RubyQt6::QtWidgets::QListView::Movement
+        define_qenum_under<QListView::Movement>(rb_cQListView, "Movement");
+        define_qenum_value_under(rb_cQListViewMovement, "Static", QListView::Movement::Static);
+        define_qenum_value_under(rb_cQListViewMovement, "Free", QListView::Movement::Free);
+        define_qenum_value_under(rb_cQListViewMovement, "Snap", QListView::Movement::Snap);
+
+    Data_Type<QListView::ResizeMode> rb_cQListViewResizeMode =
+        // RubyQt6::QtWidgets::QListView::ResizeMode
+        define_qenum_under<QListView::ResizeMode>(rb_cQListView, "ResizeMode");
+        define_qenum_value_under(rb_cQListViewResizeMode, "Fixed", QListView::ResizeMode::Fixed);
+        define_qenum_value_under(rb_cQListViewResizeMode, "Adjust", QListView::ResizeMode::Adjust);
+
+    Data_Type<QListView::ViewMode> rb_cQListViewViewMode =
+        // RubyQt6::QtWidgets::QListView::ViewMode
+        define_qenum_under<QListView::ViewMode>(rb_cQListView, "ViewMode");
+        define_qenum_value_under(rb_cQListViewViewMode, "ListMode", QListView::ViewMode::ListMode);
+        define_qenum_value_under(rb_cQListViewViewMode, "IconMode", QListView::ViewMode::IconMode);
+}

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

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

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

@@ -0,0 +1,126 @@
+#include "qlistwidget-rb.hpp"
+#include <qlistwidget.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QMimeData>
+
+using namespace Rice;
+
+Rice::Class rb_cQListWidget;
+Rice::Class rb_cQListWidgetItem;
+
+void Init_qlistwidget(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQListWidget =
+        // RubyQt6::QtWidgets::QListWidget
+        define_class_under<QListWidget, QListView>(rb_mQt6QtWidgets, "QListWidget")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QListWidget::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QListWidget, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method<void (QListWidget::*)(QListWidgetItem *)>("_add_item", &QListWidget::addItem, Arg("item"))
+            .define_method<void (QListWidget::*)(const QString &)>("_add_item", &QListWidget::addItem, Arg("label"))
+            .define_method("add_items", &QListWidget::addItems, Arg("labels"))
+            .define_method("close_persistent_editor", &QListWidget::closePersistentEditor, Arg("item"))
+            .define_method("count", &QListWidget::count)
+            .define_method("current_item", &QListWidget::currentItem)
+            .define_method("current_row", &QListWidget::currentRow)
+            .define_method("edit_item", &QListWidget::editItem, Arg("item"))
+            .define_method("find_items", &QListWidget::findItems, Arg("text"), Arg("flags"))
+            .define_method("index_from_item", &QListWidget::indexFromItem, Arg("item"))
+            .define_method<void (QListWidget::*)(int, QListWidgetItem *)>("insert_item", &QListWidget::insertItem, Arg("row"), Arg("item"))
+            .define_method<void (QListWidget::*)(int, const QString &)>("insert_item", &QListWidget::insertItem, Arg("row"), Arg("label"))
+            .define_method("insert_items", &QListWidget::insertItems, Arg("row"), Arg("labels"))
+            .define_method<bool (QListWidget::*)(QListWidgetItem *) const>("persistent_editor_open?", &QListWidget::isPersistentEditorOpen, Arg("item"))
+            .define_method("sorting_enabled?", &QListWidget::isSortingEnabled)
+            .define_method("item", &QListWidget::item, Arg("row"))
+            .define_method<QListWidgetItem *(QListWidget::*)(const QPoint &) const>("item_at", &QListWidget::itemAt, Arg("p"))
+            .define_method<QListWidgetItem *(QListWidget::*)(int, int) const>("item_at", &QListWidget::itemAt, Arg("x"), Arg("y"))
+            .define_method("item_from_index", &QListWidget::itemFromIndex, Arg("index"))
+            .define_method("item_widget", &QListWidget::itemWidget, Arg("item"))
+            .define_method("items", &QListWidget::items, Arg("data"))
+            .define_method("open_persistent_editor", &QListWidget::openPersistentEditor, Arg("item"))
+            .define_method("remove_item_widget", &QListWidget::removeItemWidget, Arg("item"))
+            .define_method("row", &QListWidget::row, Arg("item"))
+            .define_method("selected_items", &QListWidget::selectedItems)
+            .define_method<void (QListWidget::*)(QListWidgetItem *)>("set_current_item", &QListWidget::setCurrentItem, Arg("item"))
+            .define_method<void (QListWidget::*)(QListWidgetItem *, QItemSelectionModel::SelectionFlags)>("set_current_item", &QListWidget::setCurrentItem, Arg("item"), Arg("command"))
+            .define_method<void (QListWidget::*)(int)>("set_current_row", &QListWidget::setCurrentRow, Arg("row"))
+            .define_method<void (QListWidget::*)(int, QItemSelectionModel::SelectionFlags)>("set_current_row", &QListWidget::setCurrentRow, Arg("row"), Arg("command"))
+            .define_method("set_item_widget", &QListWidget::setItemWidget, Arg("item"), Arg("widget"))
+            .define_method("set_selection_model", &QListWidget::setSelectionModel, Arg("selection_model"))
+            .define_method("set_sorting_enabled", &QListWidget::setSortingEnabled, Arg("enable"))
+            .define_method("sort_items", &QListWidget::sortItems, Arg("order") = static_cast<Qt::SortOrder>(Qt::AscendingOrder))
+            .define_method("take_item", &QListWidget::takeItem, Arg("row"))
+            .define_method("visual_item_rect", &QListWidget::visualItemRect, Arg("item"))
+            // Public Slots
+            .define_method("clear", &QListWidget::clear)
+            .define_method("scroll_to_item", &QListWidget::scrollToItem, Arg("item"), Arg("hint") = static_cast<QAbstractItemView::ScrollHint>(QAbstractItemView::ScrollHint::EnsureVisible))
+            // Signals
+            .define_method("current_item_changed", &QListWidget::currentItemChanged, Arg("current"), Arg("previous"))
+            .define_method("current_row_changed", &QListWidget::currentRowChanged, Arg("current_row"))
+            .define_method("current_text_changed", &QListWidget::currentTextChanged, Arg("current_text"))
+            .define_method("item_activated", &QListWidget::itemActivated, Arg("item"))
+            .define_method("item_changed", &QListWidget::itemChanged, Arg("item"))
+            .define_method("item_clicked", &QListWidget::itemClicked, Arg("item"))
+            .define_method("item_double_clicked", &QListWidget::itemDoubleClicked, Arg("item"))
+            .define_method("item_entered", &QListWidget::itemEntered, Arg("item"))
+            .define_method("item_pressed", &QListWidget::itemPressed, Arg("item"))
+            .define_method("item_selection_changed", &QListWidget::itemSelectionChanged);
+
+    rb_cQListWidgetItem =
+        // RubyQt6::QtWidgets::QListWidgetItem
+        define_class_under<QListWidgetItem>(rb_mQt6QtWidgets, "QListWidgetItem")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_qvariant_register_metatype", []() -> int { return qRegisterMetaType<QListWidgetItem *>(); })
+            .define_singleton_function("_qvariant_from_value", [](QListWidgetItem *value) -> QVariant { return QVariant::fromValue(value); })
+            .define_singleton_function("_qvariant_to_value", [](const QVariant &qvariant) -> QListWidgetItem * { return qvariant.value<QListWidgetItem *>(); })
+            .define_singleton_function("_take_ownership_from_ruby", [](QListWidgetItem *) -> void {}, Arg("item").takeOwnership())
+            // Constructor
+            .define_constructor(Constructor<QListWidgetItem>())
+            .define_constructor(Constructor<QListWidgetItem, const QString &>(), Arg("text"))
+            .define_constructor(Constructor<QListWidgetItem, const QIcon &, const QString &>(), Arg("icon"), Arg("text"))
+            // Public Functions
+            .define_method("background", &QListWidgetItem::background)
+            .define_method("check_state", &QListWidgetItem::checkState)
+            .define_method("clone", &QListWidgetItem::clone)
+            .define_method("data", &QListWidgetItem::data, Arg("role"))
+            .define_method("flags", &QListWidgetItem::flags)
+            .define_method("font", &QListWidgetItem::font)
+            .define_method("foreground", &QListWidgetItem::foreground)
+            .define_method("icon", &QListWidgetItem::icon)
+            .define_method("hidden?", &QListWidgetItem::isHidden)
+            .define_method("selected?", &QListWidgetItem::isSelected)
+            .define_method("list_widget", &QListWidgetItem::listWidget)
+            .define_method("read", &QListWidgetItem::read, Arg("in"))
+            .define_method("set_background", &QListWidgetItem::setBackground, Arg("brush"))
+            .define_method("set_check_state", &QListWidgetItem::setCheckState, Arg("state"))
+            .define_method("set_data", &QListWidgetItem::setData, Arg("role"), Arg("value"))
+            .define_method("set_flags", &QListWidgetItem::setFlags, Arg("flags"))
+            .define_method("set_font", &QListWidgetItem::setFont, Arg("font"))
+            .define_method("set_foreground", &QListWidgetItem::setForeground, Arg("brush"))
+            .define_method("set_hidden", &QListWidgetItem::setHidden, Arg("hide"))
+            .define_method("set_icon", &QListWidgetItem::setIcon, Arg("icon"))
+            .define_method("set_selected", &QListWidgetItem::setSelected, Arg("select"))
+            .define_method("set_size_hint", &QListWidgetItem::setSizeHint, Arg("size"))
+            .define_method("set_status_tip", &QListWidgetItem::setStatusTip, Arg("status_tip"))
+            .define_method("set_text", &QListWidgetItem::setText, Arg("text"))
+            .define_method<void (QListWidgetItem::*)(Qt::Alignment)>("set_text_alignment", &QListWidgetItem::setTextAlignment, Arg("alignment"))
+            .define_method<void (QListWidgetItem::*)(Qt::AlignmentFlag)>("set_text_alignment", &QListWidgetItem::setTextAlignment, Arg("alignment"))
+            .define_method("set_tool_tip", &QListWidgetItem::setToolTip, Arg("tool_tip"))
+            .define_method("set_whats_this", &QListWidgetItem::setWhatsThis, Arg("whats_this"))
+            .define_method("status_tip", &QListWidgetItem::statusTip)
+            .define_method("text", &QListWidgetItem::text)
+            .define_method("text_alignment", &QListWidgetItem::textAlignment)
+            .define_method("tool_tip", &QListWidgetItem::toolTip)
+            .define_method("type", &QListWidgetItem::type)
+            .define_method("whats_this", &QListWidgetItem::whatsThis)
+            .define_method("write", &QListWidgetItem::write, Arg("out"));
+
+    Data_Type<QListWidgetItem::ItemType> rb_cQListWidgetItemItemType =
+        // RubyQt6::QtWidgets::QListWidgetItem::ItemType
+        define_qenum_under<QListWidgetItem::ItemType>(rb_cQListWidgetItem, "ItemType");
+        define_qenum_value_under(rb_cQListWidgetItemItemType, "Type", QListWidgetItem::ItemType::Type);
+        define_qenum_value_under(rb_cQListWidgetItemItemType, "UserType", QListWidgetItem::ItemType::UserType);
+}

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

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

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

@@ -0,0 +1,96 @@
+#include "qmainwindow-rb.hpp"
+#include <qmainwindow.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QDockWidget>
+#include <QMenuBar>
+#include <QStatusBar>
+#include <QToolBar>
+
+using namespace Rice;
+
+Rice::Class rb_cQMainWindow;
+
+void Init_qmainwindow(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQMainWindow =
+        // RubyQt6::QtWidgets::QMainWindow
+        define_class_under<QMainWindow, QWidget>(rb_mQt6QtWidgets, "QMainWindow")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMainWindow::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMainWindow, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method<void (QMainWindow::*)(Qt::DockWidgetArea, QDockWidget *)>("add_dock_widget", &QMainWindow::addDockWidget, Arg("area"), Arg("dockwidget"))
+            .define_method<void (QMainWindow::*)(Qt::DockWidgetArea, QDockWidget *, Qt::Orientation)>("add_dock_widget", &QMainWindow::addDockWidget, Arg("area"), Arg("dockwidget"), Arg("orientation"))
+            .define_method<QToolBar *(QMainWindow::*)(const QString &)>("_add_tool_bar", &QMainWindow::addToolBar, Arg("title"))
+            .define_method<void (QMainWindow::*)(QToolBar *)>("_add_tool_bar", &QMainWindow::addToolBar, Arg("toolbar"))
+            .define_method<void (QMainWindow::*)(Qt::ToolBarArea, QToolBar *)>("_add_tool_bar", &QMainWindow::addToolBar, Arg("area"), Arg("toolbar"))
+            .define_method("add_tool_bar_break", &QMainWindow::addToolBarBreak, Arg("area") = static_cast<Qt::ToolBarArea>(Qt::TopToolBarArea))
+            .define_method("central_widget", &QMainWindow::centralWidget)
+            .define_method("corner", &QMainWindow::corner, Arg("corner"))
+            .define_method("create_popup_menu", &QMainWindow::createPopupMenu)
+            .define_method("dock_options", &QMainWindow::dockOptions)
+            .define_method("dock_widget_area", &QMainWindow::dockWidgetArea, Arg("dockwidget"))
+            .define_method("document_mode", &QMainWindow::documentMode)
+            .define_method("icon_size", &QMainWindow::iconSize)
+            .define_method("insert_tool_bar", &QMainWindow::insertToolBar, Arg("before"), Arg("toolbar"))
+            .define_method("insert_tool_bar_break", &QMainWindow::insertToolBarBreak, Arg("before"))
+            .define_method("animated?", &QMainWindow::isAnimated)
+            .define_method("dock_nesting_enabled?", &QMainWindow::isDockNestingEnabled)
+            .define_method("separator?", &QMainWindow::isSeparator, Arg("pos"))
+            .define_method("menu_bar", &QMainWindow::menuBar)
+            .define_method("menu_widget", &QMainWindow::menuWidget)
+            .define_method("remove_dock_widget", &QMainWindow::removeDockWidget, Arg("dockwidget"))
+            .define_method("remove_tool_bar", &QMainWindow::removeToolBar, Arg("toolbar"))
+            .define_method("remove_tool_bar_break", &QMainWindow::removeToolBarBreak, Arg("before"))
+            .define_method("resize_docks", &QMainWindow::resizeDocks, Arg("docks"), Arg("sizes"), Arg("orientation"))
+            .define_method("restore_dock_widget", &QMainWindow::restoreDockWidget, Arg("dockwidget"))
+            .define_method("restore_state", &QMainWindow::restoreState, Arg("state"), Arg("version") = static_cast<int>(0))
+            .define_method("save_state", &QMainWindow::saveState, Arg("version") = static_cast<int>(0))
+            .define_method("set_central_widget", &QMainWindow::setCentralWidget, Arg("widget"))
+            .define_method("set_corner", &QMainWindow::setCorner, Arg("corner"), Arg("area"))
+            .define_method("set_dock_options", &QMainWindow::setDockOptions, Arg("options"))
+            .define_method("set_document_mode", &QMainWindow::setDocumentMode, Arg("enabled"))
+            .define_method("set_icon_size", &QMainWindow::setIconSize, Arg("icon_size"))
+            .define_method("set_menu_bar", &QMainWindow::setMenuBar, Arg("menubar"))
+            .define_method("set_menu_widget", &QMainWindow::setMenuWidget, Arg("menubar"))
+            .define_method("set_status_bar", &QMainWindow::setStatusBar, Arg("statusbar"))
+            .define_method("set_tab_position", &QMainWindow::setTabPosition, Arg("areas"), Arg("tab_position"))
+            .define_method("set_tab_shape", &QMainWindow::setTabShape, Arg("tab_shape"))
+            .define_method("set_tool_button_style", &QMainWindow::setToolButtonStyle, Arg("tool_button_style"))
+            .define_method("split_dock_widget", &QMainWindow::splitDockWidget, Arg("after"), Arg("dockwidget"), Arg("orientation"))
+            .define_method("status_bar", &QMainWindow::statusBar)
+            .define_method("tab_position", &QMainWindow::tabPosition, Arg("area"))
+            .define_method("tab_shape", &QMainWindow::tabShape)
+            .define_method("tabified_dock_widgets", &QMainWindow::tabifiedDockWidgets, Arg("dockwidget"))
+            .define_method("tabify_dock_widget", &QMainWindow::tabifyDockWidget, Arg("first"), Arg("second"))
+            .define_method("take_central_widget", &QMainWindow::takeCentralWidget)
+            .define_method("tool_bar_area", &QMainWindow::toolBarArea, Arg("toolbar"))
+            .define_method("tool_bar_break", &QMainWindow::toolBarBreak, Arg("toolbar"))
+            .define_method("tool_button_style", &QMainWindow::toolButtonStyle)
+            .define_method("unified_title_and_tool_bar_on_mac", &QMainWindow::unifiedTitleAndToolBarOnMac)
+            // Public Slots
+            .define_method("set_animated", &QMainWindow::setAnimated, Arg("enabled"))
+            .define_method("set_dock_nesting_enabled", &QMainWindow::setDockNestingEnabled, Arg("enabled"))
+            .define_method("set_unified_title_and_tool_bar_on_mac", &QMainWindow::setUnifiedTitleAndToolBarOnMac, Arg("set"))
+            // Signals
+            .define_method("icon_size_changed", &QMainWindow::iconSizeChanged, Arg("icon_size"))
+            .define_method("tabified_dock_widget_activated", &QMainWindow::tabifiedDockWidgetActivated, Arg("dock_widget"))
+            .define_method("tool_button_style_changed", &QMainWindow::toolButtonStyleChanged, Arg("tool_button_style"));
+
+    Data_Type<QMainWindow::DockOption> rb_cQMainWindowDockOption =
+        // RubyQt6::QtWidgets::QMainWindow::DockOption
+        define_qenum_under<QMainWindow::DockOption>(rb_cQMainWindow, "DockOption");
+        define_qenum_value_under(rb_cQMainWindowDockOption, "AnimatedDocks", QMainWindow::DockOption::AnimatedDocks);
+        define_qenum_value_under(rb_cQMainWindowDockOption, "AllowNestedDocks", QMainWindow::DockOption::AllowNestedDocks);
+        define_qenum_value_under(rb_cQMainWindowDockOption, "AllowTabbedDocks", QMainWindow::DockOption::AllowTabbedDocks);
+        define_qenum_value_under(rb_cQMainWindowDockOption, "ForceTabbedDocks", QMainWindow::DockOption::ForceTabbedDocks);
+        define_qenum_value_under(rb_cQMainWindowDockOption, "VerticalTabs", QMainWindow::DockOption::VerticalTabs);
+        define_qenum_value_under(rb_cQMainWindowDockOption, "GroupedDragging", QMainWindow::DockOption::GroupedDragging);
+
+    Data_Type<QFlags<QMainWindow::DockOption>> rb_cQMainWindowDockOptions =
+        // RubyQt6::QtWidgets::QMainWindow::DockOptions
+        define_qflags_under<QMainWindow::DockOption>(rb_cQMainWindow, "DockOptions");
+}

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

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

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

@@ -0,0 +1,77 @@
+#include "qmdiarea-rb.hpp"
+#include <qmdiarea.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QMdiSubWindow>
+
+using namespace Rice;
+
+Rice::Class rb_cQMdiArea;
+
+void Init_qmdiarea(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQMdiArea =
+        // RubyQt6::QtWidgets::QMdiArea
+        define_class_under<QMdiArea, QAbstractScrollArea>(rb_mQt6QtWidgets, "QMdiArea")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMdiArea::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMdiArea, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("activation_order", &QMdiArea::activationOrder)
+            .define_method("active_sub_window", &QMdiArea::activeSubWindow)
+            .define_method("add_sub_window", &QMdiArea::addSubWindow, Arg("widget"), Arg("flags") = static_cast<Qt::WindowFlags>(Qt::WindowFlags()))
+            .define_method("background", &QMdiArea::background)
+            .define_method("current_sub_window", &QMdiArea::currentSubWindow)
+            .define_method("document_mode", &QMdiArea::documentMode)
+            .define_method("remove_sub_window", &QMdiArea::removeSubWindow, Arg("widget"))
+            .define_method("set_activation_order", &QMdiArea::setActivationOrder, Arg("order"))
+            .define_method("set_background", &QMdiArea::setBackground, Arg("background"))
+            .define_method("set_document_mode", &QMdiArea::setDocumentMode, Arg("enabled"))
+            .define_method("set_option", &QMdiArea::setOption, Arg("option"), Arg("on") = static_cast<bool>(true))
+            .define_method("set_tab_position", &QMdiArea::setTabPosition, Arg("position"))
+            .define_method("set_tab_shape", &QMdiArea::setTabShape, Arg("shape"))
+            .define_method("set_tabs_closable", &QMdiArea::setTabsClosable, Arg("closable"))
+            .define_method("set_tabs_movable", &QMdiArea::setTabsMovable, Arg("movable"))
+            .define_method("set_view_mode", &QMdiArea::setViewMode, Arg("mode"))
+            .define_method("sub_window_list", &QMdiArea::subWindowList, Arg("order") = static_cast<QMdiArea::WindowOrder>(QMdiArea::WindowOrder::CreationOrder))
+            .define_method("tab_position", &QMdiArea::tabPosition)
+            .define_method("tab_shape", &QMdiArea::tabShape)
+            .define_method("tabs_closable", &QMdiArea::tabsClosable)
+            .define_method("tabs_movable", &QMdiArea::tabsMovable)
+            .define_method("test_option", &QMdiArea::testOption, Arg("opton"))
+            .define_method("view_mode", &QMdiArea::viewMode)
+            // Public Slots
+            .define_method("activate_next_sub_window", &QMdiArea::activateNextSubWindow)
+            .define_method("activate_previous_sub_window", &QMdiArea::activatePreviousSubWindow)
+            .define_method("cascade_sub_windows", &QMdiArea::cascadeSubWindows)
+            .define_method("close_active_sub_window", &QMdiArea::closeActiveSubWindow)
+            .define_method("close_all_sub_windows", &QMdiArea::closeAllSubWindows)
+            .define_method("set_active_sub_window", &QMdiArea::setActiveSubWindow, Arg("window"))
+            .define_method("tile_sub_windows", &QMdiArea::tileSubWindows)
+            // Signals
+            .define_method("sub_window_activated", &QMdiArea::subWindowActivated, Arg("window"));
+
+    Data_Type<QMdiArea::AreaOption> rb_cQMdiAreaAreaOption =
+        // RubyQt6::QtWidgets::QMdiArea::AreaOption
+        define_qenum_under<QMdiArea::AreaOption>(rb_cQMdiArea, "AreaOption");
+        define_qenum_value_under(rb_cQMdiAreaAreaOption, "DontMaximizeSubWindowOnActivation", QMdiArea::AreaOption::DontMaximizeSubWindowOnActivation);
+
+    Data_Type<QMdiArea::ViewMode> rb_cQMdiAreaViewMode =
+        // RubyQt6::QtWidgets::QMdiArea::ViewMode
+        define_qenum_under<QMdiArea::ViewMode>(rb_cQMdiArea, "ViewMode");
+        define_qenum_value_under(rb_cQMdiAreaViewMode, "SubWindowView", QMdiArea::ViewMode::SubWindowView);
+        define_qenum_value_under(rb_cQMdiAreaViewMode, "TabbedView", QMdiArea::ViewMode::TabbedView);
+
+    Data_Type<QMdiArea::WindowOrder> rb_cQMdiAreaWindowOrder =
+        // RubyQt6::QtWidgets::QMdiArea::WindowOrder
+        define_qenum_under<QMdiArea::WindowOrder>(rb_cQMdiArea, "WindowOrder");
+        define_qenum_value_under(rb_cQMdiAreaWindowOrder, "CreationOrder", QMdiArea::WindowOrder::CreationOrder);
+        define_qenum_value_under(rb_cQMdiAreaWindowOrder, "StackingOrder", QMdiArea::WindowOrder::StackingOrder);
+        define_qenum_value_under(rb_cQMdiAreaWindowOrder, "ActivationHistoryOrder", QMdiArea::WindowOrder::ActivationHistoryOrder);
+
+    Data_Type<QFlags<QMdiArea::AreaOption>> rb_cQMdiAreaAreaOptions =
+        // RubyQt6::QtWidgets::QMdiArea::AreaOptions
+        define_qflags_under<QMdiArea::AreaOption>(rb_cQMdiArea, "AreaOptions");
+}

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

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

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

@@ -0,0 +1,55 @@
+#include "qmdisubwindow-rb.hpp"
+#include <qmdisubwindow.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QMdiArea>
+#include <QMenu>
+
+using namespace Rice;
+
+Rice::Class rb_cQMdiSubWindow;
+
+void Init_qmdisubwindow(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQMdiSubWindow =
+        // RubyQt6::QtWidgets::QMdiSubWindow
+        define_class_under<QMdiSubWindow, QWidget>(rb_mQt6QtWidgets, "QMdiSubWindow")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMdiSubWindow::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMdiSubWindow, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("shaded?", &QMdiSubWindow::isShaded)
+            .define_method("keyboard_page_step", &QMdiSubWindow::keyboardPageStep)
+            .define_method("keyboard_single_step", &QMdiSubWindow::keyboardSingleStep)
+            .define_method("maximized_buttons_widget", &QMdiSubWindow::maximizedButtonsWidget)
+            .define_method("maximized_system_menu_icon_widget", &QMdiSubWindow::maximizedSystemMenuIconWidget)
+            .define_method("mdi_area", &QMdiSubWindow::mdiArea)
+            .define_method("set_keyboard_page_step", &QMdiSubWindow::setKeyboardPageStep, Arg("step"))
+            .define_method("set_keyboard_single_step", &QMdiSubWindow::setKeyboardSingleStep, Arg("step"))
+            .define_method("set_option", &QMdiSubWindow::setOption, Arg("option"), Arg("on") = static_cast<bool>(true))
+            .define_method("set_system_menu", &QMdiSubWindow::setSystemMenu, Arg("system_menu"))
+            .define_method("set_widget", &QMdiSubWindow::setWidget, Arg("widget"))
+            .define_method("system_menu", &QMdiSubWindow::systemMenu)
+            .define_method("test_option", &QMdiSubWindow::testOption, Arg("option"))
+            .define_method("_widget", &QMdiSubWindow::widget)
+            // Public Slots
+            .define_method("show_shaded", &QMdiSubWindow::showShaded)
+            .define_method("show_system_menu", &QMdiSubWindow::showSystemMenu)
+            // Signals
+            .define_method("about_to_activate", &QMdiSubWindow::aboutToActivate)
+            .define_method("window_state_changed", &QMdiSubWindow::windowStateChanged, Arg("old_state"), Arg("new_state"));
+
+    Data_Type<QMdiSubWindow::SubWindowOption> rb_cQMdiSubWindowSubWindowOption =
+        // RubyQt6::QtWidgets::QMdiSubWindow::SubWindowOption
+        define_qenum_under<QMdiSubWindow::SubWindowOption>(rb_cQMdiSubWindow, "SubWindowOption");
+        define_qenum_value_under(rb_cQMdiSubWindowSubWindowOption, "AllowOutsideAreaHorizontally", QMdiSubWindow::SubWindowOption::AllowOutsideAreaHorizontally);
+        define_qenum_value_under(rb_cQMdiSubWindowSubWindowOption, "AllowOutsideAreaVertically", QMdiSubWindow::SubWindowOption::AllowOutsideAreaVertically);
+        define_qenum_value_under(rb_cQMdiSubWindowSubWindowOption, "RubberBandResize", QMdiSubWindow::SubWindowOption::RubberBandResize);
+        define_qenum_value_under(rb_cQMdiSubWindowSubWindowOption, "RubberBandMove", QMdiSubWindow::SubWindowOption::RubberBandMove);
+
+    Data_Type<QFlags<QMdiSubWindow::SubWindowOption>> rb_cQMdiSubWindowSubWindowOptions =
+        // RubyQt6::QtWidgets::QMdiSubWindow::SubWindowOptions
+        define_qflags_under<QMdiSubWindow::SubWindowOption>(rb_cQMdiSubWindow, "SubWindowOptions");
+}

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

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