ruby-qt6-qtgui 1.0.0

data/ext/qt6/qtgui/qpainter-rb.hpp

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

data/ext/qt6/qtgui/qpainterpath-rb.cpp

@@ -0,0 +1,100 @@
+#include "qpainterpath-rb.hpp"
+#include <qpainterpath.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QFont>
+
+using namespace Rice;
+
+Rice::Class rb_cQPainterPath;
+Rice::Class rb_cQPainterPathElement;
+
+void Init_qpainterpath(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQPainterPath =
+        // RubyQt6::QtGui::QPainterPath
+        define_class_under<QPainterPath>(rb_mQt6QtGui, "QPainterPath")
+            // Constructor
+            .define_constructor(Constructor<QPainterPath>())
+            .define_constructor(Constructor<QPainterPath, const QPointF &>(), Arg("start_point"))
+            // Public Functions
+            .define_method<void (QPainterPath::*)(const QPointF &, qreal, qreal)>("add_ellipse", &QPainterPath::addEllipse, Arg("center"), Arg("rx"), Arg("ry"))
+            .define_method<void (QPainterPath::*)(const QRectF &)>("add_ellipse", &QPainterPath::addEllipse, Arg("rect"))
+            .define_method<void (QPainterPath::*)(qreal, qreal, qreal, qreal)>("add_ellipse", &QPainterPath::addEllipse, Arg("x"), Arg("y"), Arg("w"), Arg("h"))
+            .define_method("add_path", &QPainterPath::addPath, Arg("path"))
+            .define_method("add_polygon", &QPainterPath::addPolygon, Arg("polygon"))
+            .define_method<void (QPainterPath::*)(const QRectF &)>("add_rect", &QPainterPath::addRect, Arg("rect"))
+            .define_method<void (QPainterPath::*)(qreal, qreal, qreal, qreal)>("add_rect", &QPainterPath::addRect, Arg("x"), Arg("y"), Arg("w"), Arg("h"))
+            .define_method("add_region", &QPainterPath::addRegion, Arg("region"))
+            .define_method<void (QPainterPath::*)(const QRectF &, qreal, qreal, Qt::SizeMode)>("add_rounded_rect", &QPainterPath::addRoundedRect, Arg("rect"), Arg("x_radius"), Arg("y_radius"), Arg("mode") = static_cast<Qt::SizeMode>(Qt::AbsoluteSize))
+            .define_method<void (QPainterPath::*)(qreal, qreal, qreal, qreal, qreal, qreal, Qt::SizeMode)>("add_rounded_rect", &QPainterPath::addRoundedRect, Arg("x"), Arg("y"), Arg("w"), Arg("h"), Arg("x_radius"), Arg("y_radius"), Arg("mode") = static_cast<Qt::SizeMode>(Qt::AbsoluteSize))
+            .define_method<void (QPainterPath::*)(const QPointF &, const QFont &, const QString &)>("add_text", &QPainterPath::addText, Arg("point"), Arg("f"), Arg("text"))
+            .define_method<void (QPainterPath::*)(qreal, qreal, const QFont &, const QString &)>("add_text", &QPainterPath::addText, Arg("x"), Arg("y"), Arg("f"), Arg("text"))
+            .define_method("angle_at_percent", &QPainterPath::angleAtPercent, Arg("t"))
+            .define_method<void (QPainterPath::*)(const QRectF &, qreal)>("arc_move_to", &QPainterPath::arcMoveTo, Arg("rect"), Arg("angle"))
+            .define_method<void (QPainterPath::*)(qreal, qreal, qreal, qreal, qreal)>("arc_move_to", &QPainterPath::arcMoveTo, Arg("x"), Arg("y"), Arg("w"), Arg("h"), Arg("angle"))
+            .define_method<void (QPainterPath::*)(const QRectF &, qreal, qreal)>("arc_to", &QPainterPath::arcTo, Arg("rect"), Arg("start_angle"), Arg("arc_length"))
+            .define_method<void (QPainterPath::*)(qreal, qreal, qreal, qreal, qreal, qreal)>("arc_to", &QPainterPath::arcTo, Arg("x"), Arg("y"), Arg("w"), Arg("h"), Arg("start_angle"), Arg("arc_length"))
+            .define_method("bounding_rect", &QPainterPath::boundingRect)
+            .define_method("capacity", &QPainterPath::capacity)
+            .define_method("clear", &QPainterPath::clear)
+            .define_method("close_subpath", &QPainterPath::closeSubpath)
+            .define_method("connect_path", &QPainterPath::connectPath, Arg("path"))
+            .define_method<bool (QPainterPath::*)(const QPainterPath &) const>("contains", &QPainterPath::contains, Arg("p"))
+            .define_method<bool (QPainterPath::*)(const QPointF &) const>("contains", &QPainterPath::contains, Arg("pt"))
+            .define_method<bool (QPainterPath::*)(const QRectF &) const>("contains", &QPainterPath::contains, Arg("rect"))
+            .define_method("control_point_rect", &QPainterPath::controlPointRect)
+            .define_method<void (QPainterPath::*)(const QPointF &, const QPointF &, const QPointF &)>("cubic_to", &QPainterPath::cubicTo, Arg("ctrl_pt1"), Arg("ctrl_pt2"), Arg("end_pt"))
+            .define_method<void (QPainterPath::*)(qreal, qreal, qreal, qreal, qreal, qreal)>("cubic_to", &QPainterPath::cubicTo, Arg("ctrl_pt1x"), Arg("ctrl_pt1y"), Arg("ctrl_pt2x"), Arg("ctrl_pt2y"), Arg("end_ptx"), Arg("end_pty"))
+            .define_method("current_position", &QPainterPath::currentPosition)
+            .define_method("element_at", &QPainterPath::elementAt, Arg("i"))
+            .define_method("element_count", &QPainterPath::elementCount)
+            .define_method("fill_rule", &QPainterPath::fillRule)
+            .define_method("intersected", &QPainterPath::intersected, Arg("r"))
+            .define_method<bool (QPainterPath::*)(const QPainterPath &) const>("intersects", &QPainterPath::intersects, Arg("p"))
+            .define_method<bool (QPainterPath::*)(const QRectF &) const>("intersects", &QPainterPath::intersects, Arg("rect"))
+            .define_method("empty?", &QPainterPath::isEmpty)
+            .define_method("length", &QPainterPath::length)
+            .define_method<void (QPainterPath::*)(const QPointF &)>("line_to", &QPainterPath::lineTo, Arg("p"))
+            .define_method<void (QPainterPath::*)(qreal, qreal)>("line_to", &QPainterPath::lineTo, Arg("x"), Arg("y"))
+            .define_method<void (QPainterPath::*)(const QPointF &)>("move_to", &QPainterPath::moveTo, Arg("p"))
+            .define_method<void (QPainterPath::*)(qreal, qreal)>("move_to", &QPainterPath::moveTo, Arg("x"), Arg("y"))
+            .define_method("percent_at_length", &QPainterPath::percentAtLength, Arg("t"))
+            .define_method("point_at_percent", &QPainterPath::pointAtPercent, Arg("t"))
+            .define_method<void (QPainterPath::*)(const QPointF &, const QPointF &)>("quad_to", &QPainterPath::quadTo, Arg("ctrl_pt"), Arg("end_pt"))
+            .define_method<void (QPainterPath::*)(qreal, qreal, qreal, qreal)>("quad_to", &QPainterPath::quadTo, Arg("ctrl_ptx"), Arg("ctrl_pty"), Arg("end_ptx"), Arg("end_pty"))
+            .define_method("reserve", &QPainterPath::reserve, Arg("size"))
+            .define_method("set_element_position_at", &QPainterPath::setElementPositionAt, Arg("i"), Arg("x"), Arg("y"))
+            .define_method("set_fill_rule", &QPainterPath::setFillRule, Arg("fill_rule"))
+            .define_method("simplified", &QPainterPath::simplified)
+            .define_method("slope_at_percent", &QPainterPath::slopeAtPercent, Arg("t"))
+            .define_method("subtracted", &QPainterPath::subtracted, Arg("r"))
+            .define_method("to_fill_polygon", &QPainterPath::toFillPolygon, Arg("matrix") = static_cast<const QTransform &>(QTransform()))
+            .define_method("to_fill_polygons", &QPainterPath::toFillPolygons, Arg("matrix") = static_cast<const QTransform &>(QTransform()))
+            .define_method("to_reversed", &QPainterPath::toReversed)
+            .define_method("to_subpath_polygons", &QPainterPath::toSubpathPolygons, Arg("matrix") = static_cast<const QTransform &>(QTransform()))
+            .define_method<void (QPainterPath::*)(const QPointF &)>("translate", &QPainterPath::translate, Arg("offset"))
+            .define_method<void (QPainterPath::*)(qreal, qreal)>("translate", &QPainterPath::translate, Arg("dx"), Arg("dy"))
+            .define_method<QPainterPath (QPainterPath::*)(const QPointF &) const>("translated", &QPainterPath::translated, Arg("offset"))
+            .define_method<QPainterPath (QPainterPath::*)(qreal, qreal) const>("translated", &QPainterPath::translated, Arg("dx"), Arg("dy"))
+            .define_method("united", &QPainterPath::united, Arg("r"));
+
+    Data_Type<QPainterPath::ElementType> rb_cQPainterPathElementType =
+        // RubyQt6::QtGui::QPainterPath::ElementType
+        define_qenum_under<QPainterPath::ElementType>(rb_cQPainterPath, "ElementType");
+        define_qenum_value_under(rb_cQPainterPathElementType, "MoveToElement", QPainterPath::ElementType::MoveToElement);
+        define_qenum_value_under(rb_cQPainterPathElementType, "LineToElement", QPainterPath::ElementType::LineToElement);
+        define_qenum_value_under(rb_cQPainterPathElementType, "CurveToElement", QPainterPath::ElementType::CurveToElement);
+        define_qenum_value_under(rb_cQPainterPathElementType, "CurveToDataElement", QPainterPath::ElementType::CurveToDataElement);
+
+    rb_cQPainterPathElement =
+        // RubyQt6::QtGui::QPainterPath::Element
+        define_class_under<QPainterPath::Element>(rb_cQPainterPath, "Element")
+            .define_constructor(Constructor<QPainterPath::Element>())
+            .define_attr("x", &QPainterPath::Element::x)
+            .define_attr("y", &QPainterPath::Element::y)
+            // .define_attr("type", &QPainterPath::Element::type)
+            .define_method("curve_to?", &QPainterPath::Element::isCurveTo)
+            .define_method("line_to?", &QPainterPath::Element::isLineTo)
+            .define_method("move_to?", &QPainterPath::Element::isMoveTo);
+}

data/ext/qt6/qtgui/qpainterpath-rb.hpp

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

data/ext/qt6/qtgui/qpainterpathstroker-rb.cpp

@@ -0,0 +1,35 @@
+#include "qpainterpathstroker-rb.hpp"
+#include <qpainterpath.h>
+
+#include <QPen>
+
+using namespace Rice;
+
+Rice::Class rb_cQPainterPathStroker;
+
+void Init_qpainterpathstroker(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQPainterPathStroker =
+        // RubyQt6::QtGui::QPainterPathStroker
+        define_class_under<QPainterPathStroker>(rb_mQt6QtGui, "QPainterPathStroker")
+            // Constructor
+            .define_constructor(Constructor<QPainterPathStroker>())
+            .define_constructor(Constructor<QPainterPathStroker, const QPen &>(), Arg("pen"))
+            // Public Functions
+            .define_method("cap_style", &QPainterPathStroker::capStyle)
+            .define_method("create_stroke", &QPainterPathStroker::createStroke, Arg("path"))
+            .define_method("curve_threshold", &QPainterPathStroker::curveThreshold)
+            .define_method("dash_offset", &QPainterPathStroker::dashOffset)
+            .define_method("dash_pattern", &QPainterPathStroker::dashPattern)
+            .define_method("join_style", &QPainterPathStroker::joinStyle)
+            .define_method("miter_limit", &QPainterPathStroker::miterLimit)
+            .define_method("set_cap_style", &QPainterPathStroker::setCapStyle, Arg("style"))
+            .define_method("set_curve_threshold", &QPainterPathStroker::setCurveThreshold, Arg("threshold"))
+            .define_method("set_dash_offset", &QPainterPathStroker::setDashOffset, Arg("offset"))
+            .define_method<void (QPainterPathStroker::*)(Qt::PenStyle)>("set_dash_pattern", &QPainterPathStroker::setDashPattern, Arg("style"))
+            .define_method<void (QPainterPathStroker::*)(const QList<qreal> &)>("set_dash_pattern", &QPainterPathStroker::setDashPattern, Arg("dash_pattern"))
+            .define_method("set_join_style", &QPainterPathStroker::setJoinStyle, Arg("style"))
+            .define_method("set_miter_limit", &QPainterPathStroker::setMiterLimit, Arg("length"))
+            .define_method("set_width", &QPainterPathStroker::setWidth, Arg("width"))
+            .define_method("width", &QPainterPathStroker::width);
+}

data/ext/qt6/qtgui/qpainterpathstroker-rb.hpp

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

data/ext/qt6/qtgui/qpalette-rb.cpp

@@ -0,0 +1,96 @@
+#include "qpalette-rb.hpp"
+#include <qpalette.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQPalette;
+
+void Init_qpalette(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQPalette =
+        // RubyQt6::QtGui::QPalette
+        define_class_under<QPalette>(rb_mQt6QtGui, "QPalette")
+            // Constructor
+            .define_constructor(Constructor<QPalette>())
+            .define_constructor(Constructor<QPalette, const QColor &>(), Arg("button"))
+            .define_constructor(Constructor<QPalette, const QColor &, const QColor &>(), Arg("button"), Arg("window"))
+            // Public Functions
+            .define_method("accent", &QPalette::accent)
+            .define_method("alternate_base", &QPalette::alternateBase)
+            .define_method("base", &QPalette::base)
+            .define_method("bright_text", &QPalette::brightText)
+            .define_method<const QBrush &(QPalette::*)(QPalette::ColorGroup, QPalette::ColorRole) const>("brush", &QPalette::brush, Arg("cg"), Arg("cr"))
+            .define_method<const QBrush &(QPalette::*)(QPalette::ColorRole) const>("brush", &QPalette::brush, Arg("cr"))
+            .define_method("button", &QPalette::button)
+            .define_method("button_text", &QPalette::buttonText)
+            .define_method("cache_key", &QPalette::cacheKey)
+            .define_method<const QColor &(QPalette::*)(QPalette::ColorGroup, QPalette::ColorRole) const>("color", &QPalette::color, Arg("cg"), Arg("cr"))
+            .define_method<const QColor &(QPalette::*)(QPalette::ColorRole) const>("color", &QPalette::color, Arg("cr"))
+            .define_method("current_color_group", &QPalette::currentColorGroup)
+            .define_method("dark", &QPalette::dark)
+            .define_method("highlight", &QPalette::highlight)
+            .define_method("highlighted_text", &QPalette::highlightedText)
+            .define_method("brush_set?", &QPalette::isBrushSet, Arg("cg"), Arg("cr"))
+            .define_method("copy_of?", &QPalette::isCopyOf, Arg("p"))
+            .define_method("equal?", &QPalette::isEqual, Arg("cr1"), Arg("cr2"))
+            .define_method("light", &QPalette::light)
+            .define_method("link", &QPalette::link)
+            .define_method("link_visited", &QPalette::linkVisited)
+            .define_method("mid", &QPalette::mid)
+            .define_method("midlight", &QPalette::midlight)
+            .define_method("placeholder_text", &QPalette::placeholderText)
+            .define_method("resolve", &QPalette::resolve, Arg("other"))
+            .define_method("resolve_mask", &QPalette::resolveMask)
+            .define_method<void (QPalette::*)(QPalette::ColorGroup, QPalette::ColorRole, const QBrush &)>("set_brush", &QPalette::setBrush, Arg("cg"), Arg("cr"), Arg("brush"))
+            .define_method<void (QPalette::*)(QPalette::ColorRole, const QBrush &)>("set_brush", &QPalette::setBrush, Arg("cr"), Arg("brush"))
+            .define_method<void (QPalette::*)(QPalette::ColorGroup, QPalette::ColorRole, const QColor &)>("set_color", &QPalette::setColor, Arg("cg"), Arg("cr"), Arg("color"))
+            .define_method<void (QPalette::*)(QPalette::ColorRole, const QColor &)>("set_color", &QPalette::setColor, Arg("cr"), Arg("color"))
+            .define_method<void (QPalette::*)(QPalette::ColorGroup, const QBrush &, const QBrush &, const QBrush &, const QBrush &, const QBrush &, const QBrush &, const QBrush &, const QBrush &, const QBrush &)>("set_color_group", &QPalette::setColorGroup, Arg("cr"), Arg("window_text"), Arg("button"), Arg("light"), Arg("dark"), Arg("mid"), Arg("text"), Arg("bright_text"), Arg("base"), Arg("window"))
+            .define_method("set_current_color_group", &QPalette::setCurrentColorGroup, Arg("cg"))
+            .define_method("set_resolve_mask", &QPalette::setResolveMask, Arg("mask"))
+            .define_method("shadow", &QPalette::shadow)
+            .define_method("text", &QPalette::text)
+            .define_method("tool_tip_base", &QPalette::toolTipBase)
+            .define_method("tool_tip_text", &QPalette::toolTipText)
+            .define_method("window", &QPalette::window)
+            .define_method("window_text", &QPalette::windowText);
+
+    Data_Type<QPalette::ColorGroup> rb_cQPaletteColorGroup =
+        // RubyQt6::QtGui::QPalette::ColorGroup
+        define_qenum_under<QPalette::ColorGroup>(rb_cQPalette, "ColorGroup");
+        define_qenum_value_under(rb_cQPaletteColorGroup, "Active", QPalette::ColorGroup::Active);
+        define_qenum_value_under(rb_cQPaletteColorGroup, "Disabled", QPalette::ColorGroup::Disabled);
+        define_qenum_value_under(rb_cQPaletteColorGroup, "Inactive", QPalette::ColorGroup::Inactive);
+        define_qenum_value_under(rb_cQPaletteColorGroup, "NColorGroups", QPalette::ColorGroup::NColorGroups);
+        define_qenum_value_under(rb_cQPaletteColorGroup, "Current", QPalette::ColorGroup::Current);
+        define_qenum_value_under(rb_cQPaletteColorGroup, "All", QPalette::ColorGroup::All);
+        define_qenum_value_under(rb_cQPaletteColorGroup, "Normal", QPalette::ColorGroup::Normal);
+
+    Data_Type<QPalette::ColorRole> rb_cQPaletteColorRole =
+        // RubyQt6::QtGui::QPalette::ColorRole
+        define_qenum_under<QPalette::ColorRole>(rb_cQPalette, "ColorRole");
+        define_qenum_value_under(rb_cQPaletteColorRole, "WindowText", QPalette::ColorRole::WindowText);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Button", QPalette::ColorRole::Button);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Light", QPalette::ColorRole::Light);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Midlight", QPalette::ColorRole::Midlight);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Dark", QPalette::ColorRole::Dark);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Mid", QPalette::ColorRole::Mid);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Text", QPalette::ColorRole::Text);
+        define_qenum_value_under(rb_cQPaletteColorRole, "BrightText", QPalette::ColorRole::BrightText);
+        define_qenum_value_under(rb_cQPaletteColorRole, "ButtonText", QPalette::ColorRole::ButtonText);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Base", QPalette::ColorRole::Base);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Window", QPalette::ColorRole::Window);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Shadow", QPalette::ColorRole::Shadow);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Highlight", QPalette::ColorRole::Highlight);
+        define_qenum_value_under(rb_cQPaletteColorRole, "HighlightedText", QPalette::ColorRole::HighlightedText);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Link", QPalette::ColorRole::Link);
+        define_qenum_value_under(rb_cQPaletteColorRole, "LinkVisited", QPalette::ColorRole::LinkVisited);
+        define_qenum_value_under(rb_cQPaletteColorRole, "AlternateBase", QPalette::ColorRole::AlternateBase);
+        define_qenum_value_under(rb_cQPaletteColorRole, "NoRole", QPalette::ColorRole::NoRole);
+        define_qenum_value_under(rb_cQPaletteColorRole, "ToolTipBase", QPalette::ColorRole::ToolTipBase);
+        define_qenum_value_under(rb_cQPaletteColorRole, "ToolTipText", QPalette::ColorRole::ToolTipText);
+        define_qenum_value_under(rb_cQPaletteColorRole, "PlaceholderText", QPalette::ColorRole::PlaceholderText);
+        define_qenum_value_under(rb_cQPaletteColorRole, "Accent", QPalette::ColorRole::Accent);
+        define_qenum_value_under(rb_cQPaletteColorRole, "NColorRoles", QPalette::ColorRole::NColorRoles);
+}

data/ext/qt6/qtgui/qpalette-rb.hpp

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

data/ext/qt6/qtgui/qpen-rb.cpp

@@ -0,0 +1,46 @@
+#include "qpen-rb.hpp"
+#include <qpen.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQPen;
+
+void Init_qpen(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQPen =
+        // RubyQt6::QtGui::QPen
+        define_class_under<QPen>(rb_mQt6QtGui, "QPen")
+            // Constructor
+            .define_constructor(Constructor<QPen>())
+            .define_constructor(Constructor<QPen, Qt::PenStyle>(), Arg("style"))
+            .define_constructor(Constructor<QPen, const QColor &>(), Arg("color"))
+            .define_constructor(Constructor<QPen, const QBrush &, qreal>(), Arg("brush"), Arg("width"))
+            .define_constructor(Constructor<QPen, const QBrush &, qreal, Qt::PenStyle>(), Arg("brush"), Arg("width"), Arg("style"))
+            .define_constructor(Constructor<QPen, const QBrush &, qreal, Qt::PenStyle, Qt::PenCapStyle>(), Arg("brush"), Arg("width"), Arg("style"), Arg("cap"))
+            .define_constructor(Constructor<QPen, const QBrush &, qreal, Qt::PenStyle, Qt::PenCapStyle, Qt::PenJoinStyle>(), Arg("brush"), Arg("width"), Arg("style"), Arg("cap"), Arg("join"))
+            // Public Functions
+            .define_method("brush", &QPen::brush)
+            .define_method("cap_style", &QPen::capStyle)
+            .define_method("color", &QPen::color)
+            .define_method("dash_offset", &QPen::dashOffset)
+            .define_method("dash_pattern", &QPen::dashPattern)
+            .define_method("cosmetic?", &QPen::isCosmetic)
+            .define_method("detached?", &QPen::isDetached)
+            .define_method("solid?", &QPen::isSolid)
+            .define_method("join_style", &QPen::joinStyle)
+            .define_method("miter_limit", &QPen::miterLimit)
+            .define_method("set_brush", &QPen::setBrush, Arg("brush"))
+            .define_method("set_cap_style", &QPen::setCapStyle, Arg("pcs"))
+            .define_method("set_color", &QPen::setColor, Arg("color"))
+            .define_method("set_cosmetic", &QPen::setCosmetic, Arg("cosmetic"))
+            .define_method("set_dash_offset", &QPen::setDashOffset, Arg("doffset"))
+            .define_method("set_dash_pattern", &QPen::setDashPattern, Arg("pattern"))
+            .define_method("set_join_style", &QPen::setJoinStyle, Arg("pcs"))
+            .define_method("set_miter_limit", &QPen::setMiterLimit, Arg("limit"))
+            .define_method("set_style", &QPen::setStyle, Arg("style"))
+            .define_method("set_width", &QPen::setWidth, Arg("width"))
+            .define_method("set_width_f", &QPen::setWidthF, Arg("width"))
+            .define_method("style", &QPen::style)
+            .define_method("width", &QPen::width)
+            .define_method("width_f", &QPen::widthF);
+}

data/ext/qt6/qtgui/qpen-rb.hpp

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

data/ext/qt6/qtgui/qpicture-rb.cpp

@@ -0,0 +1,33 @@
+#include "qpicture-rb.hpp"
+#include <qpicture.h>
+
+#include <QPaintEngine>
+#include <QPainter>
+
+using namespace Rice;
+
+Rice::Class rb_cQPicture;
+
+void Init_qpicture(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQPicture =
+        // RubyQt6::QtGui::QPicture
+        define_class_under<QPicture, QPaintDevice>(rb_mQt6QtGui, "QPicture")
+            // Constructor
+            .define_constructor(Constructor<QPicture>())
+            // Public Functions
+            .define_method("bounding_rect", &QPicture::boundingRect)
+            .define_method("data", &QPicture::data)
+            .define_method("detach", &QPicture::detach)
+            .define_method("dev_type", &QPicture::devType)
+            .define_method("detached?", &QPicture::isDetached)
+            .define_method("null?", &QPicture::isNull)
+            .define_method<bool (QPicture::*)(QIODevice *)>("load", &QPicture::load, Arg("dev"))
+            .define_method<bool (QPicture::*)(const QString &)>("load", &QPicture::load, Arg("file_name"))
+            .define_method("play", &QPicture::play, Arg("p"))
+            .define_method<bool (QPicture::*)(QIODevice *)>("save", &QPicture::save, Arg("dev"))
+            .define_method<bool (QPicture::*)(const QString &)>("save", &QPicture::save, Arg("file_name"))
+            .define_method("set_bounding_rect", &QPicture::setBoundingRect, Arg("r"))
+            .define_method("set_data", &QPicture::setData, Arg("data"), Arg("size"))
+            .define_method("size", &QPicture::size);
+}

data/ext/qt6/qtgui/qpicture-rb.hpp

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

data/ext/qt6/qtgui/qpixmap-rb.cpp

@@ -0,0 +1,66 @@
+#include "qpixmap-rb.hpp"
+#include <qpixmap.h>
+
+#include <QBitmap>
+#include <QImageReader>
+#include <QIODevice>
+#include <QPaintEngine>
+
+using namespace Rice;
+
+Rice::Class rb_cQPixmap;
+
+void Init_qpixmap(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQPixmap =
+        // RubyQt6::QtGui::QPixmap
+        define_class_under<QPixmap, QPaintDevice>(rb_mQt6QtGui, "QPixmap")
+            // Constructor
+            .define_constructor(Constructor<QPixmap>())
+            .define_constructor(Constructor<QPixmap, int, int>(), Arg("w"), Arg("h"))
+            .define_constructor(Constructor<QPixmap, const QSize &>(), Arg("size"))
+            .define_constructor(Constructor<QPixmap, const QString &>(), Arg("file_name"))
+            // Public Functions
+            .define_method("cache_key", &QPixmap::cacheKey)
+            .define_method("convert_from_image", &QPixmap::convertFromImage, Arg("img"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_method<QPixmap (QPixmap::*)(const QRect &) const>("copy", &QPixmap::copy, Arg("rect") = static_cast<const QRect &>(QRect()))
+            .define_method<QPixmap (QPixmap::*)(int, int, int, int) const>("copy", &QPixmap::copy, Arg("x"), Arg("y"), Arg("width"), Arg("height"))
+            .define_method("create_heuristic_mask", &QPixmap::createHeuristicMask, Arg("clip_tight") = static_cast<bool>(true))
+            .define_method("create_mask_from_color", &QPixmap::createMaskFromColor, Arg("mask_color"), Arg("mode") = static_cast<Qt::MaskMode>(Qt::MaskInColor))
+            .define_method("depth", &QPixmap::depth)
+            .define_method("detach", &QPixmap::detach)
+            .define_method("dev_type", &QPixmap::devType)
+            .define_method("device_independent_size", &QPixmap::deviceIndependentSize)
+            .define_method("device_pixel_ratio", &QPixmap::devicePixelRatio)
+            .define_method("fill", &QPixmap::fill, Arg("fill_color") = static_cast<const QColor &>(Qt::white))
+            .define_method("has_alpha", &QPixmap::hasAlpha)
+            .define_method("has_alpha_channel", &QPixmap::hasAlphaChannel)
+            .define_method("height", &QPixmap::height)
+            .define_method("detached?", &QPixmap::isDetached)
+            .define_method("null?", &QPixmap::isNull)
+            .define_method("qbitmap?", &QPixmap::isQBitmap)
+            .define_method("load", &QPixmap::load, Arg("file_name"), Arg("format") = static_cast<const char *>(nullptr), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_method<bool (QPixmap::*)(const QByteArray &, const char *, Qt::ImageConversionFlags)>("load_from_data", &QPixmap::loadFromData, Arg("data"), Arg("format") = static_cast<const char *>(nullptr), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_method<bool (QPixmap::*)(const uchar *, ::uint, const char *, Qt::ImageConversionFlags)>("load_from_data", &QPixmap::loadFromData, Arg("buf"), Arg("len"), Arg("format") = static_cast<const char *>(nullptr), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_method("mask", &QPixmap::mask)
+            .define_method("rect", &QPixmap::rect)
+            .define_method<bool (QPixmap::*)(QIODevice *, const char *, int) const>("save", &QPixmap::save, Arg("device"), Arg("format") = static_cast<const char *>(nullptr), Arg("quality") = static_cast<int>(-1))
+            .define_method<bool (QPixmap::*)(const QString &, const char *, int) const>("save", &QPixmap::save, Arg("file_name"), Arg("format") = static_cast<const char *>(nullptr), Arg("quality") = static_cast<int>(-1))
+            .define_method<QPixmap (QPixmap::*)(const QSize &, Qt::AspectRatioMode, Qt::TransformationMode) const>("scaled", &QPixmap::scaled, Arg("s"), Arg("aspect_mode") = static_cast<Qt::AspectRatioMode>(Qt::IgnoreAspectRatio), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method<QPixmap (QPixmap::*)(int, int, Qt::AspectRatioMode, Qt::TransformationMode) const>("scaled", &QPixmap::scaled, Arg("w"), Arg("h"), Arg("aspect_mode") = static_cast<Qt::AspectRatioMode>(Qt::IgnoreAspectRatio), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method("scaled_to_height", &QPixmap::scaledToHeight, Arg("h"), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method("scaled_to_width", &QPixmap::scaledToWidth, Arg("w"), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method<void (QPixmap::*)(int, int, const QRect &, QRegion *)>("scroll", &QPixmap::scroll, Arg("dx"), Arg("dy"), Arg("rect"), Arg("exposed") = static_cast<QRegion *>(nullptr))
+            .define_method<void (QPixmap::*)(int, int, int, int, int, int, QRegion *)>("scroll", &QPixmap::scroll, Arg("dx"), Arg("dy"), Arg("x"), Arg("y"), Arg("width"), Arg("height"), Arg("exposed") = static_cast<QRegion *>(nullptr))
+            .define_method("set_device_pixel_ratio", &QPixmap::setDevicePixelRatio, Arg("scale_factor"))
+            .define_method("set_mask", &QPixmap::setMask, Arg("mask"))
+            .define_method("size", &QPixmap::size)
+            .define_method("to_image", &QPixmap::toImage)
+            .define_method("transformed", &QPixmap::transformed, Arg("transform"), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method("width", &QPixmap::width)
+            // Static Public Members
+            .define_singleton_function("default_depth", &QPixmap::defaultDepth)
+            .define_singleton_function<QPixmap (*)(QImage &&, Qt::ImageConversionFlags)>("from_image", &QPixmap::fromImage, Arg("image"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_singleton_function("from_image_reader", &QPixmap::fromImageReader, Arg("image_reader"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_singleton_function("true_matrix", &QPixmap::trueMatrix, Arg("m"), Arg("w"), Arg("h"));
+}

data/ext/qt6/qtgui/qpixmap-rb.hpp

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

data/ext/qt6/qtgui/qpolygon-rb.cpp

@@ -0,0 +1,54 @@
+#include "qpolygon-rb.hpp"
+#include <qpolygon.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQPolygon;
+Rice::Class rb_cQPolygonF;
+
+void Init_qpolygon(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQPolygon =
+        // RubyQt6::QtGui::QPolygon
+        define_class_under<QPolygon, QList<QPoint>>(rb_mQt6QtGui, "QPolygon")
+            // Constructor
+            .define_constructor(Constructor<QPolygon>())
+            // Public Functions
+            .define_method("bounding_rect", &QPolygon::boundingRect)
+            .define_method("contains_point", &QPolygon::containsPoint, Arg("pt"), Arg("fill_rule"))
+            .define_method("intersected", &QPolygon::intersected, Arg("r"))
+            .define_method("intersects", &QPolygon::intersects, Arg("r"))
+            .define_method<QPoint (QPolygon::*)(int) const>("point", &QPolygon::point, Arg("i"))
+            .define_method<void (QPolygon::*)(int, int, const QPolygon &, int)>("put_points", &QPolygon::putPoints, Arg("index"), Arg("n_points"), Arg("from"), Arg("from_index") = static_cast<int>(0))
+            // .define_method<void (QPolygon::*)(int, int, int, int)>("put_points", &QPolygon::putPoints, Arg("index"), Arg("n_points"), Arg("firstx"), Arg("firsty"))
+            .define_method<void (QPolygon::*)(int, const QPoint &)>("set_point", &QPolygon::setPoint, Arg("index"), Arg("p"))
+            .define_method<void (QPolygon::*)(int, int, int)>("set_point", &QPolygon::setPoint, Arg("index"), Arg("x"), Arg("y"))
+            // .define_method<void (QPolygon::*)(int, int, int)>("set_points", &QPolygon::setPoints, Arg("n_points"), Arg("firstx"), Arg("firsty"))
+            .define_method("subtracted", &QPolygon::subtracted, Arg("r"))
+            .define_method("to_polygon_f", &QPolygon::toPolygonF)
+            .define_method<void (QPolygon::*)(const QPoint &)>("translate", &QPolygon::translate, Arg("offset"))
+            .define_method<void (QPolygon::*)(int, int)>("translate", &QPolygon::translate, Arg("dx"), Arg("dy"))
+            .define_method<QPolygon (QPolygon::*)(const QPoint &) const>("translated", &QPolygon::translated, Arg("offset"))
+            .define_method<QPolygon (QPolygon::*)(int, int) const>("translated", &QPolygon::translated, Arg("dx"), Arg("dy"))
+            .define_method("united", &QPolygon::united, Arg("r"));
+
+    rb_cQPolygonF =
+        // RubyQt6::QtGui::QPolygonF
+        define_class_under<QPolygonF, QList<QPointF>>(rb_mQt6QtGui, "QPolygonF")
+            // Constructor
+            .define_constructor(Constructor<QPolygonF>())
+            .define_constructor(Constructor<QPolygonF, const QPolygon &>(), Arg("polygon"))
+            // Public Functions
+            .define_method("bounding_rect", &QPolygonF::boundingRect)
+            .define_method("contains_point", &QPolygonF::containsPoint, Arg("pt"), Arg("fill_rule"))
+            .define_method("intersected", &QPolygonF::intersected, Arg("r"))
+            .define_method("intersects", &QPolygonF::intersects, Arg("r"))
+            .define_method("closed?", &QPolygonF::isClosed)
+            .define_method("subtracted", &QPolygonF::subtracted, Arg("r"))
+            .define_method("to_polygon", &QPolygonF::toPolygon)
+            .define_method<void (QPolygonF::*)(const QPointF &)>("translate", &QPolygonF::translate, Arg("offset"))
+            .define_method<void (QPolygonF::*)(qreal, qreal)>("translate", &QPolygonF::translate, Arg("dx"), Arg("dy"))
+            .define_method<QPolygonF (QPolygonF::*)(const QPointF &) const>("translated", &QPolygonF::translated, Arg("offset"))
+            .define_method<QPolygonF (QPolygonF::*)(qreal, qreal) const>("translated", &QPolygonF::translated, Arg("dx"), Arg("dy"))
+            .define_method("united", &QPolygonF::united, Arg("r"));
+}

data/ext/qt6/qtgui/qpolygon-rb.hpp

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

data/ext/qt6/qtgui/qregion-rb.cpp

@@ -0,0 +1,54 @@
+#include "qregion-rb.hpp"
+#include <qregion.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QBitmap>
+#include <QPolygon>
+
+using namespace Rice;
+
+Rice::Class rb_cQRegion;
+
+void Init_qregion(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQRegion =
+        // RubyQt6::QtGui::QRegion
+        define_class_under<QRegion>(rb_mQt6QtGui, "QRegion")
+            // Constructor
+            .define_constructor(Constructor<QRegion>())
+            .define_constructor(Constructor<QRegion, int, int, int, int>(), Arg("x"), Arg("y"), Arg("w"), Arg("h"))
+            .define_constructor(Constructor<QRegion, int, int, int, int, QRegion::RegionType>(), Arg("x"), Arg("y"), Arg("w"), Arg("h"), Arg("t"))
+            .define_constructor(Constructor<QRegion, const QRect &>(), Arg("r"))
+            .define_constructor(Constructor<QRegion, const QRect &, QRegion::RegionType>(), Arg("r"), Arg("t"))
+            // Public Functions
+            .define_method("bounding_rect", &QRegion::boundingRect)
+            .define_method("cbegin", &QRegion::cbegin)
+            .define_method("cend", &QRegion::cend)
+            .define_method<bool (QRegion::*)(const QPoint &) const>("contains", &QRegion::contains, Arg("p"))
+            .define_method<bool (QRegion::*)(const QRect &) const>("contains", &QRegion::contains, Arg("r"))
+            .define_method("crbegin", &QRegion::crbegin)
+            .define_method("crend", &QRegion::crend)
+            .define_method<QRegion (QRegion::*)(const QRect &) const>("intersected", &QRegion::intersected, Arg("r"))
+            .define_method<QRegion (QRegion::*)(const QRegion &) const>("intersected", &QRegion::intersected, Arg("r"))
+            .define_method<bool (QRegion::*)(const QRect &) const>("intersects", &QRegion::intersects, Arg("r"))
+            .define_method<bool (QRegion::*)(const QRegion &) const>("intersects", &QRegion::intersects, Arg("r"))
+            .define_method("empty?", &QRegion::isEmpty)
+            .define_method("null?", &QRegion::isNull)
+            .define_method("rect_count", &QRegion::rectCount)
+            .define_method("rects", &QRegion::rects)
+            .define_method<void (QRegion::*)(const QRect *, int)>("set_rects", &QRegion::setRects, Arg("rect"), Arg("num"))
+            .define_method("subtracted", &QRegion::subtracted, Arg("r"))
+            .define_method<void (QRegion::*)(const QPoint &)>("translate", &QRegion::translate, Arg("p"))
+            .define_method<void (QRegion::*)(int, int)>("translate", &QRegion::translate, Arg("dx"), Arg("dy"))
+            .define_method<QRegion (QRegion::*)(const QPoint &) const>("translated", &QRegion::translated, Arg("p"))
+            .define_method<QRegion (QRegion::*)(int, int) const>("translated", &QRegion::translated, Arg("dx"), Arg("dy"))
+            .define_method<QRegion (QRegion::*)(const QRect &) const>("united", &QRegion::united, Arg("r"))
+            .define_method<QRegion (QRegion::*)(const QRegion &) const>("united", &QRegion::united, Arg("r"))
+            .define_method("xored", &QRegion::xored, Arg("r"));
+
+    Data_Type<QRegion::RegionType> rb_cQRegionRegionType =
+        // RubyQt6::QtGui::QRegion::RegionType
+        define_qenum_under<QRegion::RegionType>(rb_cQRegion, "RegionType");
+        define_qenum_value_under(rb_cQRegionRegionType, "Rectangle", QRegion::RegionType::Rectangle);
+        define_qenum_value_under(rb_cQRegionRegionType, "Ellipse", QRegion::RegionType::Ellipse);
+}

data/ext/qt6/qtgui/qregion-rb.hpp

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

data/ext/qt6/qtgui/qscreen-rb.cpp

@@ -0,0 +1,61 @@
+#include "qscreen-rb.hpp"
+#include <qscreen.h>
+
+#include <QPixmap>
+
+using namespace Rice;
+
+Rice::Class rb_cQScreen;
+
+void Init_qscreen(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQScreen =
+        // RubyQt6::QtGui::QScreen
+        define_class_under<QScreen, QObject>(rb_mQt6QtGui, "QScreen")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QScreen::staticMetaObject; })
+            // Public Functions
+            .define_method("angle_between", &QScreen::angleBetween, Arg("a"), Arg("b"))
+            .define_method("available_geometry", &QScreen::availableGeometry)
+            .define_method("available_size", &QScreen::availableSize)
+            .define_method("available_virtual_geometry", &QScreen::availableVirtualGeometry)
+            .define_method("available_virtual_size", &QScreen::availableVirtualSize)
+            .define_method("depth", &QScreen::depth)
+            .define_method("device_pixel_ratio", &QScreen::devicePixelRatio)
+            .define_method("geometry", &QScreen::geometry)
+            .define_method("grab_window", &QScreen::grabWindow, Arg("window") = static_cast<WId>(0), Arg("x") = static_cast<int>(0), Arg("y") = static_cast<int>(0), Arg("w") = static_cast<int>(-1), Arg("h") = static_cast<int>(-1))
+            .define_method("landscape?", &QScreen::isLandscape, Arg("orientation"))
+            .define_method("portrait?", &QScreen::isPortrait, Arg("orientation"))
+            .define_method("logical_dots_per_inch", &QScreen::logicalDotsPerInch)
+            .define_method("logical_dots_per_inch_x", &QScreen::logicalDotsPerInchX)
+            .define_method("logical_dots_per_inch_y", &QScreen::logicalDotsPerInchY)
+            .define_method("manufacturer", &QScreen::manufacturer)
+            .define_method("map_between", &QScreen::mapBetween, Arg("a"), Arg("b"), Arg("rect"))
+            .define_method("model", &QScreen::model)
+            .define_method("name", &QScreen::name)
+            .define_method("native_orientation", &QScreen::nativeOrientation)
+            .define_method("orientation", &QScreen::orientation)
+            .define_method("physical_dots_per_inch", &QScreen::physicalDotsPerInch)
+            .define_method("physical_dots_per_inch_x", &QScreen::physicalDotsPerInchX)
+            .define_method("physical_dots_per_inch_y", &QScreen::physicalDotsPerInchY)
+            .define_method("physical_size", &QScreen::physicalSize)
+            .define_method("primary_orientation", &QScreen::primaryOrientation)
+            .define_method("refresh_rate", &QScreen::refreshRate)
+            .define_method("serial_number", &QScreen::serialNumber)
+            .define_method("size", &QScreen::size)
+            .define_method("transform_between", &QScreen::transformBetween, Arg("a"), Arg("b"), Arg("target"))
+            .define_method("virtual_geometry", &QScreen::virtualGeometry)
+            .define_method("virtual_sibling_at", &QScreen::virtualSiblingAt, Arg("point"))
+            .define_method("virtual_siblings", &QScreen::virtualSiblings)
+            .define_method("virtual_size", &QScreen::virtualSize)
+            // Signals
+            .define_method("available_geometry_changed", &QScreen::availableGeometryChanged, Arg("geometry"))
+            .define_method("geometry_changed", &QScreen::geometryChanged, Arg("geometry"))
+            .define_method("logical_dots_per_inch_changed", &QScreen::logicalDotsPerInchChanged, Arg("dpi"))
+            .define_method("orientation_changed", &QScreen::orientationChanged, Arg("orientation"))
+            .define_method("physical_dots_per_inch_changed", &QScreen::physicalDotsPerInchChanged, Arg("dpi"))
+            .define_method("physical_size_changed", &QScreen::physicalSizeChanged, Arg("size"))
+            .define_method("primary_orientation_changed", &QScreen::primaryOrientationChanged, Arg("orientation"))
+            .define_method("refresh_rate_changed", &QScreen::refreshRateChanged, Arg("refresh_rate"))
+            .define_method("virtual_geometry_changed", &QScreen::virtualGeometryChanged, Arg("rect"));
+}