ruby-qt6-qtwidgets 1.0.0

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

@@ -0,0 +1,63 @@
+#include "qmenu-rb.hpp"
+#include <qmenu.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQMenu;
+
+void Init_qmenu(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQMenu =
+        // RubyQt6::QtWidgets::QMenu
+        define_class_under<QMenu, QWidget>(rb_mQt6QtWidgets, "QMenu")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMenu::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMenu, const QString &, QWidget *>(), Arg("title"), Arg("parent"))
+            // Public Functions
+            .define_method("action_at", &QMenu::actionAt, Arg("pt"))
+            .define_method("action_geometry", &QMenu::actionGeometry, Arg("act"))
+            .define_method("active_action", &QMenu::activeAction)
+            .define_method<QAction *(QMenu::*)(QMenu *)>("add_menu", &QMenu::addMenu, Arg("menu"))
+            .define_method<QMenu *(QMenu::*)(const QIcon &, const QString &)>("add_menu", &QMenu::addMenu, Arg("icon"), Arg("title"))
+            .define_method<QMenu *(QMenu::*)(const QString &)>("add_menu", &QMenu::addMenu, Arg("title"))
+            .define_method<QAction *(QMenu::*)(const QIcon &, const QString &)>("add_section", &QMenu::addSection, Arg("icon"), Arg("text"))
+            .define_method<QAction *(QMenu::*)(const QString &)>("add_section", &QMenu::addSection, Arg("text"))
+            .define_method("add_separator", &QMenu::addSeparator)
+            .define_method("clear", &QMenu::clear)
+            .define_method("default_action", &QMenu::defaultAction)
+            .define_method<QAction *(QMenu::*)()>("exec", &QMenu::exec)
+            .define_method<QAction *(QMenu::*)(const QPoint &, QAction *)>("exec", &QMenu::exec, Arg("pos"), Arg("at") = static_cast<QAction *>(nullptr))
+            .define_method("hide_tear_off_menu", &QMenu::hideTearOffMenu)
+            .define_method("icon", &QMenu::icon)
+            .define_method("insert_menu", &QMenu::insertMenu, Arg("before"), Arg("menu"))
+            .define_method<QAction *(QMenu::*)(QAction *, const QIcon &, const QString &)>("insert_section", &QMenu::insertSection, Arg("before"), Arg("icon"), Arg("text"))
+            .define_method<QAction *(QMenu::*)(QAction *, const QString &)>("insert_section", &QMenu::insertSection, Arg("before"), Arg("text"))
+            .define_method("insert_separator", &QMenu::insertSeparator, Arg("before"))
+            .define_method("empty?", &QMenu::isEmpty)
+            .define_method("tear_off_enabled?", &QMenu::isTearOffEnabled)
+            .define_method("tear_off_menu_visible?", &QMenu::isTearOffMenuVisible)
+            .define_method("menu_action", &QMenu::menuAction)
+            .define_method("popup", &QMenu::popup, Arg("pos"), Arg("at") = static_cast<QAction *>(nullptr))
+            .define_method("separators_collapsible", &QMenu::separatorsCollapsible)
+            .define_method("set_active_action", &QMenu::setActiveAction, Arg("act"))
+            .define_method("set_default_action", &QMenu::setDefaultAction, Arg("act"))
+            .define_method("set_icon", &QMenu::setIcon, Arg("icon"))
+            .define_method("set_no_replay_for", &QMenu::setNoReplayFor, Arg("widget"))
+            .define_method("set_separators_collapsible", &QMenu::setSeparatorsCollapsible, Arg("collapse"))
+            .define_method("set_tear_off_enabled", &QMenu::setTearOffEnabled, Arg("enable"))
+            .define_method("set_title", &QMenu::setTitle, Arg("title"))
+            .define_method("set_tool_tips_visible", &QMenu::setToolTipsVisible, Arg("visible"))
+            .define_method<void (QMenu::*)()>("show_tear_off_menu", &QMenu::showTearOffMenu)
+            .define_method<void (QMenu::*)(const QPoint &)>("show_tear_off_menu", &QMenu::showTearOffMenu, Arg("pos"))
+            .define_method("title", &QMenu::title)
+            .define_method("tool_tips_visible", &QMenu::toolTipsVisible)
+            // Signals
+            .define_method("about_to_hide", &QMenu::aboutToHide)
+            .define_method("about_to_show", &QMenu::aboutToShow)
+            .define_method("hovered", &QMenu::hovered, Arg("action"))
+            .define_method("triggered", &QMenu::triggered, Arg("action"))
+            // Static Public Members
+            .define_singleton_function<QAction *(*)(const QList<QAction *> &, const QPoint &, QAction *, QWidget *)>("exec", &QMenu::exec, Arg("actions"), Arg("pos"), Arg("at") = static_cast<QAction *>(nullptr), Arg("parent") = static_cast<QWidget *>(nullptr))
+            .define_singleton_function("menu_in_action", &QMenu::menuInAction, Arg("action"));
+}

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

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

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

@@ -0,0 +1,40 @@
+#include "qmenubar-rb.hpp"
+#include <qmenubar.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQMenuBar;
+
+void Init_qmenubar(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQMenuBar =
+        // RubyQt6::QtWidgets::QMenuBar
+        define_class_under<QMenuBar, QWidget>(rb_mQt6QtWidgets, "QMenuBar")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMenuBar::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMenuBar, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("action_at", &QMenuBar::actionAt, Arg("pt"))
+            .define_method("action_geometry", &QMenuBar::actionGeometry, Arg("act"))
+            .define_method("active_action", &QMenuBar::activeAction)
+            .define_method<QAction *(QMenuBar::*)(QMenu *)>("_add_menu", &QMenuBar::addMenu, Arg("menu"))
+            .define_method<QMenu *(QMenuBar::*)(const QIcon &, const QString &)>("_add_menu", &QMenuBar::addMenu, Arg("icon"), Arg("title"))
+            .define_method<QMenu *(QMenuBar::*)(const QString &)>("_add_menu", &QMenuBar::addMenu, Arg("title"))
+            .define_method("add_separator", &QMenuBar::addSeparator)
+            .define_method("clear", &QMenuBar::clear)
+            .define_method("corner_widget", &QMenuBar::cornerWidget, Arg("corner") = static_cast<Qt::Corner>(Qt::TopRightCorner))
+            .define_method("insert_menu", &QMenuBar::insertMenu, Arg("before"), Arg("menu"))
+            .define_method("insert_separator", &QMenuBar::insertSeparator, Arg("before"))
+            .define_method("default_up?", &QMenuBar::isDefaultUp)
+            .define_method("native_menu_bar?", &QMenuBar::isNativeMenuBar)
+            .define_method("set_active_action", &QMenuBar::setActiveAction, Arg("action"))
+            .define_method("set_corner_widget", &QMenuBar::setCornerWidget, Arg("widget"), Arg("corner") = static_cast<Qt::Corner>(Qt::TopRightCorner))
+            .define_method("set_default_up", &QMenuBar::setDefaultUp, Arg("enable"))
+            .define_method("set_native_menu_bar", &QMenuBar::setNativeMenuBar, Arg("native_menu_bar"))
+            // Public Slots
+            .define_method("set_visible", &QMenuBar::setVisible, Arg("visible"))
+            // Signals
+            .define_method("hovered", &QMenuBar::hovered, Arg("action"))
+            .define_method("triggered", &QMenuBar::triggered, Arg("action"));
+}

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

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

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

@@ -0,0 +1,138 @@
+#include "qmessagebox-rb.hpp"
+#include <qmessagebox.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QAbstractButton>
+#include <QCheckBox>
+#include <QPushButton>
+
+using namespace Rice;
+
+Rice::Class rb_cQMessageBox;
+
+void Init_qmessagebox(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQMessageBox =
+        // RubyQt6::QtWidgets::QMessageBox
+        define_class_under<QMessageBox, QDialog>(rb_mQt6QtWidgets, "QMessageBox")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QMessageBox::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QMessageBox, QMessageBox::Icon, const QString &, const QString &, QMessageBox::StandardButtons, QWidget *>(), Arg("icon"), Arg("title"), Arg("text"), Arg("buttons"), Arg("parent"))
+            // Public Functions
+            .define_method<QPushButton *(QMessageBox::*)(QMessageBox::StandardButton)>("add_button", &QMessageBox::addButton, Arg("button"))
+            .define_method<QPushButton *(QMessageBox::*)(const QString &, QMessageBox::ButtonRole)>("add_button", &QMessageBox::addButton, Arg("text"), Arg("role"))
+            .define_method<void (QMessageBox::*)(QAbstractButton *, QMessageBox::ButtonRole)>("add_button", &QMessageBox::addButton, Arg("button"), Arg("role"))
+            .define_method("button", &QMessageBox::button, Arg("which"))
+            .define_method("button_role", &QMessageBox::buttonRole, Arg("button"))
+            .define_method("buttons", &QMessageBox::buttons)
+            .define_method("check_box", &QMessageBox::checkBox)
+            .define_method("clicked_button", &QMessageBox::clickedButton)
+            .define_method("default_button", &QMessageBox::defaultButton)
+            .define_method("detailed_text", &QMessageBox::detailedText)
+            .define_method("escape_button", &QMessageBox::escapeButton)
+            .define_method("icon", &QMessageBox::icon)
+            .define_method("icon_pixmap", &QMessageBox::iconPixmap)
+            .define_method("informative_text", &QMessageBox::informativeText)
+            .define_method<void (QMessageBox::*)(QObject *, const char *)>("open", &QMessageBox::open, Arg("receiver"), Arg("member"))
+            .define_method("options", &QMessageBox::options)
+            .define_method("remove_button", &QMessageBox::removeButton, Arg("button"))
+            .define_method("set_check_box", &QMessageBox::setCheckBox, Arg("check_box"))
+            .define_method<void (QMessageBox::*)(QMessageBox::StandardButton)>("set_default_button", &QMessageBox::setDefaultButton, Arg("button"))
+            .define_method<void (QMessageBox::*)(QPushButton *)>("set_default_button", &QMessageBox::setDefaultButton, Arg("button"))
+            .define_method("set_detailed_text", &QMessageBox::setDetailedText, Arg("text"))
+            .define_method<void (QMessageBox::*)(QAbstractButton *)>("set_escape_button", &QMessageBox::setEscapeButton, Arg("button"))
+            .define_method<void (QMessageBox::*)(QMessageBox::StandardButton)>("set_escape_button", &QMessageBox::setEscapeButton, Arg("button"))
+            .define_method("set_icon", &QMessageBox::setIcon, Arg("icon"))
+            .define_method("set_icon_pixmap", &QMessageBox::setIconPixmap, Arg("pixmap"))
+            .define_method("set_informative_text", &QMessageBox::setInformativeText, Arg("text"))
+            .define_method("set_option", &QMessageBox::setOption, Arg("option"), Arg("on") = static_cast<bool>(true))
+            .define_method("set_options", &QMessageBox::setOptions, Arg("options"))
+            .define_method("set_standard_buttons", &QMessageBox::setStandardButtons, Arg("buttons"))
+            .define_method("set_text", &QMessageBox::setText, Arg("text"))
+            .define_method("set_text_format", &QMessageBox::setTextFormat, Arg("format"))
+            .define_method("set_text_interaction_flags", &QMessageBox::setTextInteractionFlags, Arg("flags"))
+            .define_method("set_window_modality", &QMessageBox::setWindowModality, Arg("window_modality"))
+            .define_method("set_window_title", &QMessageBox::setWindowTitle, Arg("title"))
+            .define_method("standard_button", &QMessageBox::standardButton, Arg("button"))
+            .define_method("standard_buttons", &QMessageBox::standardButtons)
+            .define_method("test_option", &QMessageBox::testOption, Arg("option"))
+            .define_method("text", &QMessageBox::text)
+            .define_method("text_format", &QMessageBox::textFormat)
+            .define_method("text_interaction_flags", &QMessageBox::textInteractionFlags)
+            // Public Slots
+            // Signals
+            .define_method("button_clicked", &QMessageBox::buttonClicked, Arg("button"))
+            // Static Public Members
+            .define_singleton_function("_about", &QMessageBox::about, Arg("parent"), Arg("title"), Arg("text"))
+            .define_singleton_function("_about_qt", &QMessageBox::aboutQt, Arg("parent"), Arg("title") = static_cast<const QString &>(QString()))
+            .define_singleton_function<QMessageBox::StandardButton (*)(QWidget *, const QString &, const QString &, QMessageBox::StandardButtons, QMessageBox::StandardButton)>("_critical", &QMessageBox::critical, Arg("parent"), Arg("title"), Arg("text"), Arg("buttons") = static_cast<QMessageBox::StandardButtons>(QMessageBox::StandardButton::Ok), Arg("default_button") = static_cast<QMessageBox::StandardButton>(QMessageBox::StandardButton::NoButton))
+            .define_singleton_function<QMessageBox::StandardButton (*)(QWidget *, const QString &, const QString &, QMessageBox::StandardButtons, QMessageBox::StandardButton)>("_information", &QMessageBox::information, Arg("parent"), Arg("title"), Arg("text"), Arg("buttons") = static_cast<QMessageBox::StandardButtons>(QMessageBox::StandardButton::Ok), Arg("default_button") = static_cast<QMessageBox::StandardButton>(QMessageBox::StandardButton::NoButton))
+            .define_singleton_function<QMessageBox::StandardButton (*)(QWidget *, const QString &, const QString &, QMessageBox::StandardButtons, QMessageBox::StandardButton)>("_question", &QMessageBox::question, Arg("parent"), Arg("title"), Arg("text"), Arg("buttons") = static_cast<QMessageBox::StandardButtons>(QMessageBox::StandardButtons(QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No)), Arg("default_button") = static_cast<QMessageBox::StandardButton>(QMessageBox::StandardButton::NoButton))
+            .define_singleton_function<QMessageBox::StandardButton (*)(QWidget *, const QString &, const QString &, QMessageBox::StandardButtons, QMessageBox::StandardButton)>("_warning", &QMessageBox::warning, Arg("parent"), Arg("title"), Arg("text"), Arg("buttons") = static_cast<QMessageBox::StandardButtons>(QMessageBox::StandardButton::Ok), Arg("default_button") = static_cast<QMessageBox::StandardButton>(QMessageBox::StandardButton::NoButton));
+
+    Data_Type<QMessageBox::ButtonRole> rb_cQMessageBoxButtonRole =
+        // RubyQt6::QtWidgets::QMessageBox::ButtonRole
+        define_qenum_under<QMessageBox::ButtonRole>(rb_cQMessageBox, "ButtonRole");
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "InvalidRole", QMessageBox::ButtonRole::InvalidRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "AcceptRole", QMessageBox::ButtonRole::AcceptRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "RejectRole", QMessageBox::ButtonRole::RejectRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "DestructiveRole", QMessageBox::ButtonRole::DestructiveRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "ActionRole", QMessageBox::ButtonRole::ActionRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "HelpRole", QMessageBox::ButtonRole::HelpRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "YesRole", QMessageBox::ButtonRole::YesRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "NoRole", QMessageBox::ButtonRole::NoRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "ResetRole", QMessageBox::ButtonRole::ResetRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "ApplyRole", QMessageBox::ButtonRole::ApplyRole);
+        define_qenum_value_under(rb_cQMessageBoxButtonRole, "NRoles", QMessageBox::ButtonRole::NRoles);
+
+    Data_Type<QMessageBox::Icon> rb_cQMessageBoxIcon =
+        // RubyQt6::QtWidgets::QMessageBox::Icon
+        define_qenum_under<QMessageBox::Icon>(rb_cQMessageBox, "Icon");
+        define_qenum_value_under(rb_cQMessageBoxIcon, "NoIcon", QMessageBox::Icon::NoIcon);
+        define_qenum_value_under(rb_cQMessageBoxIcon, "Information", QMessageBox::Icon::Information);
+        define_qenum_value_under(rb_cQMessageBoxIcon, "Warning", QMessageBox::Icon::Warning);
+        define_qenum_value_under(rb_cQMessageBoxIcon, "Critical", QMessageBox::Icon::Critical);
+        define_qenum_value_under(rb_cQMessageBoxIcon, "Question", QMessageBox::Icon::Question);
+
+    Data_Type<QMessageBox::Option> rb_cQMessageBoxOption =
+        // RubyQt6::QtWidgets::QMessageBox::Option
+        define_qenum_under<QMessageBox::Option>(rb_cQMessageBox, "Option");
+        define_qenum_value_under(rb_cQMessageBoxOption, "DontUseNativeDialog", QMessageBox::Option::DontUseNativeDialog);
+
+    Data_Type<QMessageBox::StandardButton> rb_cQMessageBoxStandardButton =
+        // RubyQt6::QtWidgets::QMessageBox::StandardButton
+        define_qenum_under<QMessageBox::StandardButton>(rb_cQMessageBox, "StandardButton");
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "NoButton", QMessageBox::StandardButton::NoButton);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Ok", QMessageBox::StandardButton::Ok);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Save", QMessageBox::StandardButton::Save);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "SaveAll", QMessageBox::StandardButton::SaveAll);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Open", QMessageBox::StandardButton::Open);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Yes", QMessageBox::StandardButton::Yes);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "YesToAll", QMessageBox::StandardButton::YesToAll);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "No", QMessageBox::StandardButton::No);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "NoToAll", QMessageBox::StandardButton::NoToAll);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Abort", QMessageBox::StandardButton::Abort);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Retry", QMessageBox::StandardButton::Retry);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Ignore", QMessageBox::StandardButton::Ignore);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Close", QMessageBox::StandardButton::Close);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Cancel", QMessageBox::StandardButton::Cancel);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Discard", QMessageBox::StandardButton::Discard);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Help", QMessageBox::StandardButton::Help);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Apply", QMessageBox::StandardButton::Apply);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Reset", QMessageBox::StandardButton::Reset);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "RestoreDefaults", QMessageBox::StandardButton::RestoreDefaults);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "FirstButton", QMessageBox::StandardButton::FirstButton);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "LastButton", QMessageBox::StandardButton::LastButton);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "YesAll", QMessageBox::StandardButton::YesAll);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "NoAll", QMessageBox::StandardButton::NoAll);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Default", QMessageBox::StandardButton::Default);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "Escape", QMessageBox::StandardButton::Escape);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "FlagMask", QMessageBox::StandardButton::FlagMask);
+        define_qenum_value_under(rb_cQMessageBoxStandardButton, "ButtonMask", QMessageBox::StandardButton::ButtonMask);
+
+    Data_Type<QFlags<QMessageBox::StandardButton>> rb_cQMessageBoxStandardButtons =
+        // RubyQt6::QtWidgets::QMessageBox::StandardButtons
+        define_qflags_under<QMessageBox::StandardButton>(rb_cQMessageBox, "StandardButtons");
+}

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

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

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

@@ -0,0 +1,109 @@
+#include "qplaintextedit-rb.hpp"
+#include <qplaintextedit.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QMenu>
+#include <QPagedPaintDevice>
+#include <QPainter>
+#include <QRegularExpression>
+#include <QTextBlock>
+#include <QTextFrame>
+
+using namespace Rice;
+
+Rice::Class rb_cQPlainTextEdit;
+
+void Init_qplaintextedit(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQPlainTextEdit =
+        // RubyQt6::QtWidgets::QPlainTextEdit
+        define_class_under<QPlainTextEdit, QAbstractScrollArea>(rb_mQt6QtWidgets, "QPlainTextEdit")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QPlainTextEdit::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QPlainTextEdit, const QString &, QWidget *>(), Arg("text"), Arg("parent"))
+            // Public Functions
+            .define_method("anchor_at", &QPlainTextEdit::anchorAt, Arg("pos"))
+            .define_method("background_visible", &QPlainTextEdit::backgroundVisible)
+            .define_method("block_count", &QPlainTextEdit::blockCount)
+            .define_method("can_paste", &QPlainTextEdit::canPaste)
+            .define_method("center_on_scroll", &QPlainTextEdit::centerOnScroll)
+            .define_method<QMenu *(QPlainTextEdit::*)()>("create_standard_context_menu", &QPlainTextEdit::createStandardContextMenu)
+            .define_method<QMenu *(QPlainTextEdit::*)(const QPoint &)>("create_standard_context_menu", &QPlainTextEdit::createStandardContextMenu, Arg("position"))
+            .define_method("current_char_format", &QPlainTextEdit::currentCharFormat)
+            .define_method("cursor_for_position", &QPlainTextEdit::cursorForPosition, Arg("pos"))
+            .define_method<QRect (QPlainTextEdit::*)() const>("cursor_rect", &QPlainTextEdit::cursorRect)
+            .define_method<QRect (QPlainTextEdit::*)(const QTextCursor &) const>("cursor_rect", &QPlainTextEdit::cursorRect, Arg("cursor"))
+            .define_method("cursor_width", &QPlainTextEdit::cursorWidth)
+            .define_method("document", &QPlainTextEdit::document)
+            .define_method("document_title", &QPlainTextEdit::documentTitle)
+            .define_method("ensure_cursor_visible", &QPlainTextEdit::ensureCursorVisible)
+            .define_method("extra_selections", &QPlainTextEdit::extraSelections)
+            .define_method<bool (QPlainTextEdit::*)(const QRegularExpression &, QTextDocument::FindFlags)>("find", &QPlainTextEdit::find, Arg("exp"), Arg("options") = static_cast<QTextDocument::FindFlags>(QTextDocument::FindFlags()))
+            .define_method<bool (QPlainTextEdit::*)(const QString &, QTextDocument::FindFlags)>("find", &QPlainTextEdit::find, Arg("exp"), Arg("options") = static_cast<QTextDocument::FindFlags>(QTextDocument::FindFlags()))
+            .define_method("read_only?", &QPlainTextEdit::isReadOnly)
+            .define_method("undo_redo_enabled?", &QPlainTextEdit::isUndoRedoEnabled)
+            .define_method("line_wrap_mode", &QPlainTextEdit::lineWrapMode)
+            .define_method("load_resource", &QPlainTextEdit::loadResource, Arg("type"), Arg("name"))
+            .define_method("maximum_block_count", &QPlainTextEdit::maximumBlockCount)
+            .define_method("merge_current_char_format", &QPlainTextEdit::mergeCurrentCharFormat, Arg("modifier"))
+            .define_method("move_cursor", &QPlainTextEdit::moveCursor, Arg("operation"), Arg("mode") = static_cast<QTextCursor::MoveMode>(QTextCursor::MoveAnchor))
+            .define_method("overwrite_mode", &QPlainTextEdit::overwriteMode)
+            .define_method("placeholder_text", &QPlainTextEdit::placeholderText)
+            .define_method("print", &QPlainTextEdit::print, Arg("printer"))
+            .define_method("set_background_visible", &QPlainTextEdit::setBackgroundVisible, Arg("visible"))
+            .define_method("set_center_on_scroll", &QPlainTextEdit::setCenterOnScroll, Arg("enabled"))
+            .define_method("set_current_char_format", &QPlainTextEdit::setCurrentCharFormat, Arg("format"))
+            .define_method("set_cursor_width", &QPlainTextEdit::setCursorWidth, Arg("width"))
+            .define_method("set_document", &QPlainTextEdit::setDocument, Arg("document"))
+            .define_method("set_document_title", &QPlainTextEdit::setDocumentTitle, Arg("title"))
+            .define_method("set_extra_selections", &QPlainTextEdit::setExtraSelections, Arg("selections"))
+            .define_method("set_line_wrap_mode", &QPlainTextEdit::setLineWrapMode, Arg("mode"))
+            .define_method("set_maximum_block_count", &QPlainTextEdit::setMaximumBlockCount, Arg("maximum"))
+            .define_method("set_overwrite_mode", &QPlainTextEdit::setOverwriteMode, Arg("overwrite"))
+            .define_method("set_placeholder_text", &QPlainTextEdit::setPlaceholderText, Arg("placeholder_text"))
+            .define_method("set_read_only", &QPlainTextEdit::setReadOnly, Arg("ro"))
+            .define_method("set_tab_changes_focus", &QPlainTextEdit::setTabChangesFocus, Arg("b"))
+            .define_method("set_tab_stop_distance", &QPlainTextEdit::setTabStopDistance, Arg("distance"))
+            .define_method("set_text_cursor", &QPlainTextEdit::setTextCursor, Arg("cursor"))
+            .define_method("set_text_interaction_flags", &QPlainTextEdit::setTextInteractionFlags, Arg("flags"))
+            .define_method("set_undo_redo_enabled", &QPlainTextEdit::setUndoRedoEnabled, Arg("enable"))
+            .define_method("set_word_wrap_mode", &QPlainTextEdit::setWordWrapMode, Arg("policy"))
+            .define_method("tab_changes_focus", &QPlainTextEdit::tabChangesFocus)
+            .define_method("tab_stop_distance", &QPlainTextEdit::tabStopDistance)
+            .define_method("text_cursor", &QPlainTextEdit::textCursor)
+            .define_method("text_interaction_flags", &QPlainTextEdit::textInteractionFlags)
+            .define_method("to_plain_text", &QPlainTextEdit::toPlainText)
+            .define_method("word_wrap_mode", &QPlainTextEdit::wordWrapMode)
+            // Public Slots
+            .define_method("append_html", &QPlainTextEdit::appendHtml, Arg("html"))
+            .define_method("append_plain_text", &QPlainTextEdit::appendPlainText, Arg("text"))
+            .define_method("center_cursor", &QPlainTextEdit::centerCursor)
+            .define_method("clear", &QPlainTextEdit::clear)
+            .define_method("copy", &QPlainTextEdit::copy)
+            .define_method("cut", &QPlainTextEdit::cut)
+            .define_method("insert_plain_text", &QPlainTextEdit::insertPlainText, Arg("text"))
+            .define_method("paste", &QPlainTextEdit::paste)
+            .define_method("redo", &QPlainTextEdit::redo)
+            .define_method("select_all", &QPlainTextEdit::selectAll)
+            .define_method("set_plain_text", &QPlainTextEdit::setPlainText, Arg("text"))
+            .define_method("undo", &QPlainTextEdit::undo)
+            .define_method("zoom_in", &QPlainTextEdit::zoomIn, Arg("range") = static_cast<int>(1))
+            .define_method("zoom_out", &QPlainTextEdit::zoomOut, Arg("range") = static_cast<int>(1))
+            // Signals
+            .define_method("block_count_changed", &QPlainTextEdit::blockCountChanged, Arg("new_block_count"))
+            .define_method("copy_available", &QPlainTextEdit::copyAvailable, Arg("b"))
+            .define_method("cursor_position_changed", &QPlainTextEdit::cursorPositionChanged)
+            .define_method("modification_changed", &QPlainTextEdit::modificationChanged, Arg("b"))
+            .define_method("redo_available", &QPlainTextEdit::redoAvailable, Arg("b"))
+            .define_method("selection_changed", &QPlainTextEdit::selectionChanged)
+            .define_method("text_changed", &QPlainTextEdit::textChanged)
+            .define_method("undo_available", &QPlainTextEdit::undoAvailable, Arg("b"))
+            .define_method("update_request", &QPlainTextEdit::updateRequest, Arg("rect"), Arg("dy"));
+
+    Data_Type<QPlainTextEdit::LineWrapMode> rb_cQPlainTextEditLineWrapMode =
+        // RubyQt6::QtWidgets::QPlainTextEdit::LineWrapMode
+        define_qenum_under<QPlainTextEdit::LineWrapMode>(rb_cQPlainTextEdit, "LineWrapMode");
+        define_qenum_value_under(rb_cQPlainTextEditLineWrapMode, "NoWrap", QPlainTextEdit::LineWrapMode::NoWrap);
+        define_qenum_value_under(rb_cQPlainTextEditLineWrapMode, "WidgetWidth", QPlainTextEdit::LineWrapMode::WidgetWidth);
+}

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

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

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

@@ -0,0 +1,51 @@
+#include "qprogressbar-rb.hpp"
+#include <qprogressbar.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQProgressBar;
+
+void Init_qprogressbar(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQProgressBar =
+        // RubyQt6::QtWidgets::QProgressBar
+        define_class_under<QProgressBar, QWidget>(rb_mQt6QtWidgets, "QProgressBar")
+            // RubyQt6-Defined Functions
+            .define_method("set_alignment", [](QProgressBar *self, Qt::AlignmentFlag alignment) -> void { return self->setAlignment(alignment); }, Arg("alignment"))
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QProgressBar::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QProgressBar, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("alignment", &QProgressBar::alignment)
+            .define_method("format", &QProgressBar::format)
+            .define_method("inverted_appearance", &QProgressBar::invertedAppearance)
+            .define_method("text_visible?", &QProgressBar::isTextVisible)
+            .define_method("maximum", &QProgressBar::maximum)
+            .define_method("minimum", &QProgressBar::minimum)
+            .define_method("orientation", &QProgressBar::orientation)
+            .define_method("reset_format", &QProgressBar::resetFormat)
+            .define_method("set_alignment", &QProgressBar::setAlignment, Arg("alignment"))
+            .define_method("set_format", &QProgressBar::setFormat, Arg("format"))
+            .define_method("set_inverted_appearance", &QProgressBar::setInvertedAppearance, Arg("invert"))
+            .define_method("set_text_direction", &QProgressBar::setTextDirection, Arg("text_direction"))
+            .define_method("set_text_visible", &QProgressBar::setTextVisible, Arg("visible"))
+            .define_method("text", &QProgressBar::text)
+            .define_method("text_direction", &QProgressBar::textDirection)
+            .define_method("value", &QProgressBar::value)
+            // Public Slots
+            .define_method("reset", &QProgressBar::reset)
+            .define_method("set_maximum", &QProgressBar::setMaximum, Arg("maximum"))
+            .define_method("set_minimum", &QProgressBar::setMinimum, Arg("minimum"))
+            .define_method("set_orientation", &QProgressBar::setOrientation, Arg("orientation"))
+            .define_method("set_range", &QProgressBar::setRange, Arg("minimum"), Arg("maximum"))
+            .define_method("set_value", &QProgressBar::setValue, Arg("value"))
+            // Signals
+            .define_method("value_changed", &QProgressBar::valueChanged, Arg("value"));
+
+    Data_Type<QProgressBar::Direction> rb_cQProgressBarDirection =
+        // RubyQt6::QtWidgets::QProgressBar::Direction
+        define_qenum_under<QProgressBar::Direction>(rb_cQProgressBar, "Direction");
+        define_qenum_value_under(rb_cQProgressBarDirection, "TopToBottom", QProgressBar::Direction::TopToBottom);
+        define_qenum_value_under(rb_cQProgressBarDirection, "BottomToTop", QProgressBar::Direction::BottomToTop);
+}

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

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

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

@@ -0,0 +1,48 @@
+#include "qprogressdialog-rb.hpp"
+#include <qprogressdialog.h>
+
+#include <QLabel>
+#include <QProgressBar>
+#include <QPushButton>
+
+using namespace Rice;
+
+Rice::Class rb_cQProgressDialog;
+
+void Init_qprogressdialog(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQProgressDialog =
+        // RubyQt6::QtWidgets::QProgressDialog
+        define_class_under<QProgressDialog, QDialog>(rb_mQt6QtWidgets, "QProgressDialog")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QProgressDialog::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QProgressDialog, const QString &, const QString &, int, int, QWidget *>(), Arg("label_text"), Arg("cancel_button_text"), Arg("minimum"), Arg("maximum"), Arg("parent"))
+            // Public Functions
+            .define_method("auto_close", &QProgressDialog::autoClose)
+            .define_method("auto_reset", &QProgressDialog::autoReset)
+            .define_method("label_text", &QProgressDialog::labelText)
+            .define_method("maximum", &QProgressDialog::maximum)
+            .define_method("minimum", &QProgressDialog::minimum)
+            .define_method("minimum_duration", &QProgressDialog::minimumDuration)
+            .define_method<void (QProgressDialog::*)(QObject *, const char *)>("open", &QProgressDialog::open, Arg("receiver"), Arg("member"))
+            .define_method("set_auto_close", &QProgressDialog::setAutoClose, Arg("close"))
+            .define_method("set_auto_reset", &QProgressDialog::setAutoReset, Arg("reset"))
+            .define_method("set_bar", &QProgressDialog::setBar, Arg("bar"))
+            .define_method("set_cancel_button", &QProgressDialog::setCancelButton, Arg("button"))
+            .define_method("set_label", &QProgressDialog::setLabel, Arg("label"))
+            .define_method("value", &QProgressDialog::value)
+            .define_method("was_canceled", &QProgressDialog::wasCanceled)
+            // Public Slots
+            .define_method("cancel", &QProgressDialog::cancel)
+            .define_method("reset", &QProgressDialog::reset)
+            .define_method("set_cancel_button_text", &QProgressDialog::setCancelButtonText, Arg("text"))
+            .define_method("set_label_text", &QProgressDialog::setLabelText, Arg("text"))
+            .define_method("set_maximum", &QProgressDialog::setMaximum, Arg("maximum"))
+            .define_method("set_minimum", &QProgressDialog::setMinimum, Arg("minimum"))
+            .define_method("set_minimum_duration", &QProgressDialog::setMinimumDuration, Arg("ms"))
+            .define_method("set_range", &QProgressDialog::setRange, Arg("minimum"), Arg("maximum"))
+            .define_method("set_value", &QProgressDialog::setValue, Arg("progress"))
+            // Signals
+            .define_method("canceled", &QProgressDialog::canceled);
+}

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

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

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

@@ -0,0 +1,30 @@
+#include "qpushbutton-rb.hpp"
+#include <qpushbutton.h>
+
+#include <QMenu>
+
+using namespace Rice;
+
+Rice::Class rb_cQPushButton;
+
+void Init_qpushbutton(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQPushButton =
+        // RubyQt6::QtWidgets::QPushButton
+        define_class_under<QPushButton, QAbstractButton>(rb_mQt6QtWidgets, "QPushButton")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QPushButton::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QPushButton, const QString &, QWidget *>(), Arg("text"), Arg("parent"))
+            // Public Functions
+            .define_method("auto_default", &QPushButton::autoDefault)
+            .define_method("default?", &QPushButton::isDefault)
+            .define_method("flat?", &QPushButton::isFlat)
+            .define_method("menu", &QPushButton::menu)
+            .define_method("set_auto_default", &QPushButton::setAutoDefault, Arg("auto_default"))
+            .define_method("set_default", &QPushButton::setDefault, Arg("default"))
+            .define_method("set_flat", &QPushButton::setFlat, Arg("flat"))
+            .define_method("set_menu", &QPushButton::setMenu, Arg("menu"))
+            // Public Slots
+            .define_method("show_menu", &QPushButton::showMenu);
+}

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

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

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

@@ -0,0 +1,17 @@
+#include "qradiobutton-rb.hpp"
+#include <qradiobutton.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQRadioButton;
+
+void Init_qradiobutton(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQRadioButton =
+        // RubyQt6::QtWidgets::QRadioButton
+        define_class_under<QRadioButton, QAbstractButton>(rb_mQt6QtWidgets, "QRadioButton")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QRadioButton::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QRadioButton, const QString &, QWidget *>(), Arg("text"), Arg("parent"));
+}

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

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

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

@@ -0,0 +1,32 @@
+#include "qrubberband-rb.hpp"
+#include <qrubberband.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQRubberBand;
+
+void Init_qrubberband(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQRubberBand =
+        // RubyQt6::QtWidgets::QRubberBand
+        define_class_under<QRubberBand, QWidget>(rb_mQt6QtWidgets, "QRubberBand")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QRubberBand::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QRubberBand, QRubberBand::Shape, QWidget *>(), Arg("shape"), Arg("parent"))
+            // Public Functions
+            .define_method<void (QRubberBand::*)(const QPoint &)>("move", &QRubberBand::move, Arg("p"))
+            .define_method<void (QRubberBand::*)(int, int)>("move", &QRubberBand::move, Arg("x"), Arg("y"))
+            .define_method<void (QRubberBand::*)(const QSize &)>("resize", &QRubberBand::resize, Arg("s"))
+            .define_method<void (QRubberBand::*)(int, int)>("resize", &QRubberBand::resize, Arg("w"), Arg("h"))
+            .define_method<void (QRubberBand::*)(const QRect &)>("set_geometry", &QRubberBand::setGeometry, Arg("r"))
+            .define_method<void (QRubberBand::*)(int, int, int, int)>("set_geometry", &QRubberBand::setGeometry, Arg("x"), Arg("y"), Arg("w"), Arg("h"))
+            .define_method("shape", &QRubberBand::shape);
+
+    Data_Type<QRubberBand::Shape> rb_cQRubberBandShape =
+        // RubyQt6::QtWidgets::QRubberBand::Shape
+        define_qenum_under<QRubberBand::Shape>(rb_cQRubberBand, "Shape");
+        define_qenum_value_under(rb_cQRubberBandShape, "Line", QRubberBand::Shape::Line);
+        define_qenum_value_under(rb_cQRubberBandShape, "Rectangle", QRubberBand::Shape::Rectangle);
+}

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

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