ruby-qt6-qtwidgets 1.0.0

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

@@ -0,0 +1,29 @@
+#include "qscrollarea-rb.hpp"
+#include <qscrollarea.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQScrollArea;
+
+void Init_qscrollarea(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQScrollArea =
+        // RubyQt6::QtWidgets::QScrollArea
+        define_class_under<QScrollArea, QAbstractScrollArea>(rb_mQt6QtWidgets, "QScrollArea")
+            // RubyQt6-Defined Functions
+            .define_method("set_alignment", [](QScrollArea *self, Qt::AlignmentFlag alignment) -> void { return self->setAlignment(alignment); }, Arg("alignment"))
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QScrollArea::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QScrollArea, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("alignment", &QScrollArea::alignment)
+            .define_method("ensure_visible", &QScrollArea::ensureVisible, Arg("x"), Arg("y"), Arg("xmargin") = static_cast<int>(50), Arg("ymargin") = static_cast<int>(50))
+            .define_method("ensure_widget_visible", &QScrollArea::ensureWidgetVisible, Arg("child_widget"), Arg("xmargin") = static_cast<int>(50), Arg("ymargin") = static_cast<int>(50))
+            .define_method("focus_next_prev_child", &QScrollArea::focusNextPrevChild, Arg("next"))
+            .define_method("set_alignment", &QScrollArea::setAlignment, Arg("alignment"))
+            .define_method("set_widget", &QScrollArea::setWidget, Arg("widget"))
+            .define_method("set_widget_resizable", &QScrollArea::setWidgetResizable, Arg("resizable"))
+            .define_method("take_widget", &QScrollArea::takeWidget)
+            .define_method("widget", &QScrollArea::widget)
+            .define_method("widget_resizable", &QScrollArea::widgetResizable);
+}

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

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

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

@@ -0,0 +1,17 @@
+#include "qscrollbar-rb.hpp"
+#include <qscrollbar.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQScrollBar;
+
+void Init_qscrollbar(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQScrollBar =
+        // RubyQt6::QtWidgets::QScrollBar
+        define_class_under<QScrollBar, QAbstractSlider>(rb_mQt6QtWidgets, "QScrollBar")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QScrollBar::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QScrollBar, Qt::Orientation, QWidget *>(), Arg("orientation"), Arg("parent"));
+}

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

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

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

@@ -0,0 +1,19 @@
+#include "qsizegrip-rb.hpp"
+#include <qsizegrip.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQSizeGrip;
+
+void Init_qsizegrip(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQSizeGrip =
+        // RubyQt6::QtWidgets::QSizeGrip
+        define_class_under<QSizeGrip, QWidget>(rb_mQt6QtWidgets, "QSizeGrip")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QSizeGrip::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QSizeGrip, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("set_visible", &QSizeGrip::setVisible, Arg("visible"));
+}

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

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

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

@@ -0,0 +1,80 @@
+#include "qsizepolicy-rb.hpp"
+#include <qsizepolicy.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQSizePolicy;
+
+void Init_qsizepolicy(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQSizePolicy =
+        // RubyQt6::QtWidgets::QSizePolicy
+        define_class_under<QSizePolicy>(rb_mQt6QtWidgets, "QSizePolicy")
+            // Constructor
+            .define_constructor(Constructor<QSizePolicy>())
+            .define_constructor(Constructor<QSizePolicy, QSizePolicy::Policy, QSizePolicy::Policy>(), Arg("horizontal"), Arg("vertical"))
+            .define_constructor(Constructor<QSizePolicy, QSizePolicy::Policy, QSizePolicy::Policy, QSizePolicy::ControlType>(), Arg("horizontal"), Arg("vertical"), Arg("type"))
+            // Public Functions
+            .define_method("control_type", &QSizePolicy::controlType)
+            .define_method("expanding_directions", &QSizePolicy::expandingDirections)
+            .define_method("has_width_for_height", &QSizePolicy::hasWidthForHeight)
+            .define_method("horizontal_policy", &QSizePolicy::horizontalPolicy)
+            .define_method("horizontal_stretch", &QSizePolicy::horizontalStretch)
+            .define_method("retain_size_when_hidden", &QSizePolicy::retainSizeWhenHidden)
+            .define_method("set_control_type", &QSizePolicy::setControlType, Arg("type"))
+            .define_method("set_height_for_width", &QSizePolicy::setHeightForWidth, Arg("b"))
+            .define_method("set_horizontal_policy", &QSizePolicy::setHorizontalPolicy, Arg("d"))
+            .define_method("set_horizontal_stretch", &QSizePolicy::setHorizontalStretch, Arg("stretch_factor"))
+            .define_method("set_retain_size_when_hidden", &QSizePolicy::setRetainSizeWhenHidden, Arg("retain_size"))
+            .define_method("set_vertical_policy", &QSizePolicy::setVerticalPolicy, Arg("d"))
+            .define_method("set_vertical_stretch", &QSizePolicy::setVerticalStretch, Arg("stretch_factor"))
+            .define_method("set_width_for_height", &QSizePolicy::setWidthForHeight, Arg("b"))
+            .define_method("transpose", &QSizePolicy::transpose)
+            .define_method("transposed", &QSizePolicy::transposed)
+            .define_method("vertical_policy", &QSizePolicy::verticalPolicy)
+            .define_method("vertical_stretch", &QSizePolicy::verticalStretch);
+
+    Data_Type<QSizePolicy::ControlType> rb_cQSizePolicyControlType =
+        // RubyQt6::QtWidgets::QSizePolicy::ControlType
+        define_qenum_under<QSizePolicy::ControlType>(rb_cQSizePolicy, "ControlType");
+        define_qenum_value_under(rb_cQSizePolicyControlType, "DefaultType", QSizePolicy::ControlType::DefaultType);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "ButtonBox", QSizePolicy::ControlType::ButtonBox);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "CheckBox", QSizePolicy::ControlType::CheckBox);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "ComboBox", QSizePolicy::ControlType::ComboBox);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "Frame", QSizePolicy::ControlType::Frame);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "GroupBox", QSizePolicy::ControlType::GroupBox);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "Label", QSizePolicy::ControlType::Label);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "Line", QSizePolicy::ControlType::Line);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "LineEdit", QSizePolicy::ControlType::LineEdit);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "PushButton", QSizePolicy::ControlType::PushButton);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "RadioButton", QSizePolicy::ControlType::RadioButton);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "Slider", QSizePolicy::ControlType::Slider);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "SpinBox", QSizePolicy::ControlType::SpinBox);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "TabWidget", QSizePolicy::ControlType::TabWidget);
+        define_qenum_value_under(rb_cQSizePolicyControlType, "ToolButton", QSizePolicy::ControlType::ToolButton);
+
+    Data_Type<QSizePolicy::Policy> rb_cQSizePolicyPolicy =
+        // RubyQt6::QtWidgets::QSizePolicy::Policy
+        define_qenum_under<QSizePolicy::Policy>(rb_cQSizePolicy, "Policy");
+        define_qenum_value_under(rb_cQSizePolicyPolicy, "Fixed", QSizePolicy::Policy::Fixed);
+        define_qenum_value_under(rb_cQSizePolicyPolicy, "Minimum", QSizePolicy::Policy::Minimum);
+        define_qenum_value_under(rb_cQSizePolicyPolicy, "Maximum", QSizePolicy::Policy::Maximum);
+        define_qenum_value_under(rb_cQSizePolicyPolicy, "Preferred", QSizePolicy::Policy::Preferred);
+        define_qenum_value_under(rb_cQSizePolicyPolicy, "MinimumExpanding", QSizePolicy::Policy::MinimumExpanding);
+        define_qenum_value_under(rb_cQSizePolicyPolicy, "Expanding", QSizePolicy::Policy::Expanding);
+        define_qenum_value_under(rb_cQSizePolicyPolicy, "Ignored", QSizePolicy::Policy::Ignored);
+
+    Data_Type<QSizePolicy::PolicyFlag> rb_cQSizePolicyPolicyFlag =
+        // RubyQt6::QtWidgets::QSizePolicy::PolicyFlag
+        define_qenum_under<QSizePolicy::PolicyFlag>(rb_cQSizePolicy, "PolicyFlag");
+        define_qenum_value_under(rb_cQSizePolicyPolicyFlag, "GrowFlag", QSizePolicy::PolicyFlag::GrowFlag);
+        define_qenum_value_under(rb_cQSizePolicyPolicyFlag, "ExpandFlag", QSizePolicy::PolicyFlag::ExpandFlag);
+        define_qenum_value_under(rb_cQSizePolicyPolicyFlag, "ShrinkFlag", QSizePolicy::PolicyFlag::ShrinkFlag);
+        define_qenum_value_under(rb_cQSizePolicyPolicyFlag, "IgnoreFlag", QSizePolicy::PolicyFlag::IgnoreFlag);
+
+    Data_Type<QFlags<QSizePolicy::ControlType>> rb_cQSizePolicyControlTypes =
+        // RubyQt6::QtWidgets::QSizePolicy::ControlTypes
+        define_qflags_under<QSizePolicy::ControlType>(rb_cQSizePolicy, "ControlTypes");
+}

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

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

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

@@ -0,0 +1,33 @@
+#include "qslider-rb.hpp"
+#include <qslider.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQSlider;
+
+void Init_qslider(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQSlider =
+        // RubyQt6::QtWidgets::QSlider
+        define_class_under<QSlider, QAbstractSlider>(rb_mQt6QtWidgets, "QSlider")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QSlider::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QSlider, Qt::Orientation, QWidget *>(), Arg("orientation"), Arg("parent"))
+            // Public Functions
+            .define_method("set_tick_interval", &QSlider::setTickInterval, Arg("ti"))
+            .define_method("set_tick_position", &QSlider::setTickPosition, Arg("position"))
+            .define_method("tick_interval", &QSlider::tickInterval)
+            .define_method("tick_position", &QSlider::tickPosition);
+
+    Data_Type<QSlider::TickPosition> rb_cQSliderTickPosition =
+        // RubyQt6::QtWidgets::QSlider::TickPosition
+        define_qenum_under<QSlider::TickPosition>(rb_cQSlider, "TickPosition");
+        define_qenum_value_under(rb_cQSliderTickPosition, "NoTicks", QSlider::TickPosition::NoTicks);
+        define_qenum_value_under(rb_cQSliderTickPosition, "TicksAbove", QSlider::TickPosition::TicksAbove);
+        define_qenum_value_under(rb_cQSliderTickPosition, "TicksLeft", QSlider::TickPosition::TicksLeft);
+        define_qenum_value_under(rb_cQSliderTickPosition, "TicksBelow", QSlider::TickPosition::TicksBelow);
+        define_qenum_value_under(rb_cQSliderTickPosition, "TicksRight", QSlider::TickPosition::TicksRight);
+        define_qenum_value_under(rb_cQSliderTickPosition, "TicksBothSides", QSlider::TickPosition::TicksBothSides);
+}

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

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

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

@@ -0,0 +1,76 @@
+#include "qspinbox-rb.hpp"
+#include <qspinbox.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQDoubleSpinBox;
+Rice::Class rb_cQSpinBox;
+
+void Init_qspinbox(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQDoubleSpinBox =
+        // RubyQt6::QtWidgets::QDoubleSpinBox
+        define_class_under<QDoubleSpinBox, QAbstractSpinBox>(rb_mQt6QtWidgets, "QDoubleSpinBox")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QDoubleSpinBox::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QDoubleSpinBox, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("clean_text", &QDoubleSpinBox::cleanText)
+            .define_method("decimals", &QDoubleSpinBox::decimals)
+            .define_method("fixup", &QDoubleSpinBox::fixup, Arg("str"))
+            .define_method("maximum", &QDoubleSpinBox::maximum)
+            .define_method("minimum", &QDoubleSpinBox::minimum)
+            .define_method("prefix", &QDoubleSpinBox::prefix)
+            .define_method("set_decimals", &QDoubleSpinBox::setDecimals, Arg("prec"))
+            .define_method("set_maximum", &QDoubleSpinBox::setMaximum, Arg("max"))
+            .define_method("set_minimum", &QDoubleSpinBox::setMinimum, Arg("min"))
+            .define_method("_set_prefix", &QDoubleSpinBox::setPrefix, Arg("prefix"))
+            .define_method("set_range", &QDoubleSpinBox::setRange, Arg("min"), Arg("max"))
+            .define_method("set_single_step", &QDoubleSpinBox::setSingleStep, Arg("val"))
+            .define_method("set_step_type", &QDoubleSpinBox::setStepType, Arg("step_type"))
+            .define_method("_set_suffix", &QDoubleSpinBox::setSuffix, Arg("suffix"))
+            .define_method("single_step", &QDoubleSpinBox::singleStep)
+            .define_method("step_type", &QDoubleSpinBox::stepType)
+            .define_method("suffix", &QDoubleSpinBox::suffix)
+            .define_method("text_from_value", &QDoubleSpinBox::textFromValue, Arg("val"))
+            .define_method("validate", &QDoubleSpinBox::validate, Arg("input"), Arg("pos"))
+            .define_method("value", &QDoubleSpinBox::value)
+            .define_method("value_from_text", &QDoubleSpinBox::valueFromText, Arg("text"))
+            // Public Slots
+            .define_method("set_value", &QDoubleSpinBox::setValue, Arg("val"))
+            // Signals
+            .define_method("text_changed", &QDoubleSpinBox::textChanged, Arg("text"))
+            .define_method("value_changed", &QDoubleSpinBox::valueChanged, Arg("val"));
+
+    rb_cQSpinBox =
+        // RubyQt6::QtWidgets::QSpinBox
+        define_class_under<QSpinBox, QAbstractSpinBox>(rb_mQt6QtWidgets, "QSpinBox")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QSpinBox::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QSpinBox, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("clean_text", &QSpinBox::cleanText)
+            .define_method("display_integer_base", &QSpinBox::displayIntegerBase)
+            .define_method("maximum", &QSpinBox::maximum)
+            .define_method("minimum", &QSpinBox::minimum)
+            .define_method("prefix", &QSpinBox::prefix)
+            .define_method("set_display_integer_base", &QSpinBox::setDisplayIntegerBase, Arg("base"))
+            .define_method("set_maximum", &QSpinBox::setMaximum, Arg("max"))
+            .define_method("set_minimum", &QSpinBox::setMinimum, Arg("min"))
+            .define_method("_set_prefix", &QSpinBox::setPrefix, Arg("prefix"))
+            .define_method("set_range", &QSpinBox::setRange, Arg("min"), Arg("max"))
+            .define_method("set_single_step", &QSpinBox::setSingleStep, Arg("val"))
+            .define_method("set_step_type", &QSpinBox::setStepType, Arg("step_type"))
+            .define_method("_set_suffix", &QSpinBox::setSuffix, Arg("suffix"))
+            .define_method("single_step", &QSpinBox::singleStep)
+            .define_method("step_type", &QSpinBox::stepType)
+            .define_method("suffix", &QSpinBox::suffix)
+            .define_method("value", &QSpinBox::value)
+            // Public Slots
+            .define_method("set_value", &QSpinBox::setValue, Arg("val"))
+            // Signals
+            .define_method("text_changed", &QSpinBox::textChanged, Arg("text"))
+            .define_method("value_changed", &QSpinBox::valueChanged, Arg("val"));
+}

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

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

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

@@ -0,0 +1,30 @@
+#include "qsplashscreen-rb.hpp"
+#include <qsplashscreen.h>
+
+#include <QScreen>
+
+using namespace Rice;
+
+Rice::Class rb_cQSplashScreen;
+
+void Init_qsplashscreen(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQSplashScreen =
+        // RubyQt6::QtWidgets::QSplashScreen
+        define_class_under<QSplashScreen, QWidget>(rb_mQt6QtWidgets, "QSplashScreen")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QSplashScreen::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QSplashScreen, const QPixmap &>(), Arg("pixmap"))
+            // Public Functions
+            .define_method("finish", &QSplashScreen::finish, Arg("w"))
+            .define_method("message", &QSplashScreen::message)
+            .define_method("pixmap", &QSplashScreen::pixmap)
+            .define_method("repaint", &QSplashScreen::repaint)
+            .define_method("set_pixmap", &QSplashScreen::setPixmap, Arg("pixmap"))
+            // Public Slots
+            .define_method("clear_message", &QSplashScreen::clearMessage)
+            .define_method("show_message", &QSplashScreen::showMessage, Arg("message"), Arg("alignment") = static_cast<int>(Qt::AlignLeft), Arg("color") = static_cast<const QColor &>(Qt::black))
+            // Signals
+            .define_method("message_changed", &QSplashScreen::messageChanged, Arg("message"));
+}

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

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

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

@@ -0,0 +1,58 @@
+#include "qsplitter-rb.hpp"
+#include <qsplitter.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQSplitter;
+Rice::Class rb_cQSplitterHandle;
+
+void Init_qsplitter(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQSplitter =
+        // RubyQt6::QtWidgets::QSplitter
+        define_class_under<QSplitter, QFrame>(rb_mQt6QtWidgets, "QSplitter")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QSplitter::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QSplitter, Qt::Orientation, QWidget *>(), Arg("orientation"), Arg("parent"))
+            // Public Functions
+            .define_method("add_widget", &QSplitter::addWidget, Arg("widget"))
+            .define_method("children_collapsible", &QSplitter::childrenCollapsible)
+            .define_method("count", &QSplitter::count)
+            .define_method("get_range", &QSplitter::getRange, Arg("index"), Arg("min"), Arg("max"))
+            .define_method("handle", &QSplitter::handle, Arg("index"))
+            .define_method("handle_width", &QSplitter::handleWidth)
+            .define_method("index_of", &QSplitter::indexOf, Arg("w"))
+            .define_method("insert_widget", &QSplitter::insertWidget, Arg("index"), Arg("widget"))
+            .define_method("collapsible?", &QSplitter::isCollapsible, Arg("index"))
+            .define_method("opaque_resize", &QSplitter::opaqueResize)
+            .define_method("orientation", &QSplitter::orientation)
+            .define_method("refresh", &QSplitter::refresh)
+            .define_method("replace_widget", &QSplitter::replaceWidget, Arg("index"), Arg("widget"))
+            .define_method("restore_state", &QSplitter::restoreState, Arg("state"))
+            .define_method("save_state", &QSplitter::saveState)
+            .define_method("set_children_collapsible", &QSplitter::setChildrenCollapsible, Arg("enable"))
+            .define_method("set_collapsible", &QSplitter::setCollapsible, Arg("index"), Arg("enable"))
+            .define_method("set_handle_width", &QSplitter::setHandleWidth, Arg("w"))
+            .define_method("set_opaque_resize", &QSplitter::setOpaqueResize, Arg("opaque") = static_cast<bool>(true))
+            .define_method("set_orientation", &QSplitter::setOrientation, Arg("orientation"))
+            .define_method("set_sizes", &QSplitter::setSizes, Arg("list"))
+            .define_method("set_stretch_factor", &QSplitter::setStretchFactor, Arg("index"), Arg("stretch"))
+            .define_method("sizes", &QSplitter::sizes)
+            .define_method("widget", &QSplitter::widget, Arg("index"))
+            // Signals
+            .define_method("splitter_moved", &QSplitter::splitterMoved, Arg("pos"), Arg("index"));
+
+    rb_cQSplitterHandle =
+        // RubyQt6::QtWidgets::QSplitterHandle
+        define_class_under<QSplitterHandle, QWidget>(rb_mQt6QtWidgets, "QSplitterHandle")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QSplitterHandle::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QSplitterHandle, Qt::Orientation, QSplitter *>(), Arg("orientation"), Arg("parent"))
+            // Public Functions
+            .define_method("opaque_resize", &QSplitterHandle::opaqueResize)
+            .define_method("orientation", &QSplitterHandle::orientation)
+            .define_method("set_orientation", &QSplitterHandle::setOrientation, Arg("o"))
+            .define_method("splitter", &QSplitterHandle::splitter);
+}

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

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

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

@@ -0,0 +1,47 @@
+#include "qstackedlayout-rb.hpp"
+#include <qstackedlayout.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QWidget>
+
+using namespace Rice;
+
+Rice::Class rb_cQStackedLayout;
+
+void Init_qstackedlayout(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQStackedLayout =
+        // RubyQt6::QtWidgets::QStackedLayout
+        define_class_under<QStackedLayout, QLayout>(rb_mQt6QtWidgets, "QStackedLayout")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QStackedLayout::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QStackedLayout, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("add_item", &QStackedLayout::addItem, Arg("item"))
+            .define_method("add_widget", &QStackedLayout::addWidget, Arg("widget"))
+            .define_method("count", &QStackedLayout::count)
+            .define_method("current_index", &QStackedLayout::currentIndex)
+            .define_method("current_widget", &QStackedLayout::currentWidget)
+            .define_method("insert_widget", &QStackedLayout::insertWidget, Arg("index"), Arg("widget"))
+            .define_method("item_at", &QStackedLayout::itemAt, Arg("index"))
+            .define_method("minimum_size", &QStackedLayout::minimumSize)
+            .define_method("set_geometry", &QStackedLayout::setGeometry, Arg("rect"))
+            .define_method("set_stacking_mode", &QStackedLayout::setStackingMode, Arg("stacking_mode"))
+            .define_method("stacking_mode", &QStackedLayout::stackingMode)
+            .define_method("take_at", &QStackedLayout::takeAt, Arg("index"))
+            .define_method<QWidget* (QStackedLayout::*)(int) const>("widget", &QStackedLayout::widget, Arg("index"))
+            // Public Slots
+            .define_method("set_current_index", &QStackedLayout::setCurrentIndex, Arg("index"))
+            .define_method("set_current_widget", &QStackedLayout::setCurrentWidget, Arg("w"))
+            // Signals
+            .define_method("current_changed", &QStackedLayout::currentChanged, Arg("index"))
+            .define_method("widget_added", &QStackedLayout::widgetAdded, Arg("index"))
+            .define_method("widget_removed", &QStackedLayout::widgetRemoved, Arg("index"));
+
+    Data_Type<QStackedLayout::StackingMode> rb_cQStackedLayoutStackingMode =
+        // RubyQt6::QtWidgets::QStackedLayout::StackingMode
+        define_qenum_under<QStackedLayout::StackingMode>(rb_cQStackedLayout, "StackingMode");
+        define_qenum_value_under(rb_cQStackedLayoutStackingMode, "StackOne", QStackedLayout::StackingMode::StackOne);
+        define_qenum_value_under(rb_cQStackedLayoutStackingMode, "StackAll", QStackedLayout::StackingMode::StackAll);
+}

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

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

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

@@ -0,0 +1,33 @@
+#include "qstackedwidget-rb.hpp"
+#include <qstackedwidget.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQStackedWidget;
+
+void Init_qstackedwidget(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQStackedWidget =
+        // RubyQt6::QtWidgets::QStackedWidget
+        define_class_under<QStackedWidget, QFrame>(rb_mQt6QtWidgets, "QStackedWidget")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QStackedWidget::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QStackedWidget, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("add_widget", &QStackedWidget::addWidget, Arg("widget"))
+            .define_method("count", &QStackedWidget::count)
+            .define_method("current_index", &QStackedWidget::currentIndex)
+            .define_method("current_widget", &QStackedWidget::currentWidget)
+            .define_method("index_of", &QStackedWidget::indexOf, Arg("widget"))
+            .define_method("insert_widget", &QStackedWidget::insertWidget, Arg("index"), Arg("widget"))
+            .define_method("remove_widget", &QStackedWidget::removeWidget, Arg("w"))
+            .define_method("widget", &QStackedWidget::widget, Arg("index"))
+            // Public Slots
+            .define_method("set_current_index", &QStackedWidget::setCurrentIndex, Arg("index"))
+            .define_method("set_current_widget", &QStackedWidget::setCurrentWidget, Arg("w"))
+            // Signals
+            .define_method("current_changed", &QStackedWidget::currentChanged, Arg("index"))
+            .define_method("widget_added", &QStackedWidget::widgetAdded, Arg("index"))
+            .define_method("widget_removed", &QStackedWidget::widgetRemoved, Arg("index"));
+}

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

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

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

@@ -0,0 +1,31 @@
+#include "qstatusbar-rb.hpp"
+#include <qstatusbar.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQStatusBar;
+
+void Init_qstatusbar(Rice::Module rb_mQt6QtWidgets)
+{
+    rb_cQStatusBar =
+        // RubyQt6::QtWidgets::QStatusBar
+        define_class_under<QStatusBar, QWidget>(rb_mQt6QtWidgets, "QStatusBar")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QStatusBar::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QStatusBar, QWidget *>(), Arg("parent"))
+            // Public Functions
+            .define_method("add_permanent_widget", &QStatusBar::addPermanentWidget, Arg("widget"), Arg("stretch") = static_cast<int>(0))
+            .define_method("add_widget", &QStatusBar::addWidget, Arg("widget"), Arg("stretch") = static_cast<int>(0))
+            .define_method("current_message", &QStatusBar::currentMessage)
+            .define_method("insert_permanent_widget", &QStatusBar::insertPermanentWidget, Arg("index"), Arg("widget"), Arg("stretch") = static_cast<int>(0))
+            .define_method("insert_widget", &QStatusBar::insertWidget, Arg("index"), Arg("widget"), Arg("stretch") = static_cast<int>(0))
+            .define_method("size_grip_enabled?", &QStatusBar::isSizeGripEnabled)
+            .define_method("remove_widget", &QStatusBar::removeWidget, Arg("widget"))
+            .define_method("set_size_grip_enabled", &QStatusBar::setSizeGripEnabled, Arg("enabled"))
+            // Public Slots
+            .define_method("clear_message", &QStatusBar::clearMessage)
+            .define_method("show_message", &QStatusBar::showMessage, Arg("text"), Arg("timeout") = static_cast<int>(0))
+            // Signals
+            .define_method("message_changed", &QStatusBar::messageChanged, Arg("text"));
+}

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

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