ruby-qt6-qtgui 1.0.0

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

@@ -0,0 +1,122 @@
+#include "qcolor-rb.hpp"
+#include <qcolor.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQColor;
+
+void Init_qcolor(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQColor =
+        // RubyQt6::QtGui::QColor
+        define_class_under<QColor>(rb_mQt6QtGui, "QColor")
+            // Constructor
+            .define_constructor(Constructor<QColor>())
+            .define_constructor(Constructor<QColor, int, int, int>(), Arg("r"), Arg("g"), Arg("b"))
+            .define_constructor(Constructor<QColor, int, int, int, int>(), Arg("r"), Arg("g"), Arg("b"), Arg("a"))
+            .define_constructor(Constructor<QColor, Qt::GlobalColor>(), Arg("color"))
+            .define_constructor(Constructor<QColor, const char *>(), Arg("color"))
+            .define_constructor(Constructor<QColor, const QString &>(), Arg("color"))
+            // Public Functions
+            .define_method("alpha", &QColor::alpha)
+            .define_method("alpha_f", &QColor::alphaF)
+            .define_method("black", &QColor::black)
+            .define_method("black_f", &QColor::blackF)
+            .define_method("blue", &QColor::blue)
+            .define_method("blue_f", &QColor::blueF)
+            .define_method("convert_to", &QColor::convertTo, Arg("color_spec"))
+            .define_method("cyan", &QColor::cyan)
+            .define_method("cyan_f", &QColor::cyanF)
+            .define_method("darker", &QColor::darker, Arg("f") = static_cast<int>(200))
+            .define_method("get_cmyk", &QColor::getCmyk, Arg("c"), Arg("m"), Arg("y"), Arg("k"), Arg("a") = static_cast<int *>(nullptr))
+            .define_method("get_cmyk_f", &QColor::getCmykF, Arg("c"), Arg("m"), Arg("y"), Arg("k"), Arg("a") = static_cast<float *>(nullptr))
+            .define_method("get_hsl", &QColor::getHsl, Arg("h"), Arg("s"), Arg("l"), Arg("a") = static_cast<int *>(nullptr))
+            .define_method("get_hsl_f", &QColor::getHslF, Arg("h"), Arg("s"), Arg("l"), Arg("a") = static_cast<float *>(nullptr))
+            .define_method("get_hsv", &QColor::getHsv, Arg("h"), Arg("s"), Arg("v"), Arg("a") = static_cast<int *>(nullptr))
+            .define_method("get_hsv_f", &QColor::getHsvF, Arg("h"), Arg("s"), Arg("v"), Arg("a") = static_cast<float *>(nullptr))
+            .define_method("get_rgb", &QColor::getRgb, Arg("r"), Arg("g"), Arg("b"), Arg("a") = static_cast<int *>(nullptr))
+            .define_method("get_rgb_f", &QColor::getRgbF, Arg("r"), Arg("g"), Arg("b"), Arg("a") = static_cast<float *>(nullptr))
+            .define_method("green", &QColor::green)
+            .define_method("green_f", &QColor::greenF)
+            .define_method("hsl_hue", &QColor::hslHue)
+            .define_method("hsl_hue_f", &QColor::hslHueF)
+            .define_method("hsl_saturation", &QColor::hslSaturation)
+            .define_method("hsl_saturation_f", &QColor::hslSaturationF)
+            .define_method("hsv_hue", &QColor::hsvHue)
+            .define_method("hsv_hue_f", &QColor::hsvHueF)
+            .define_method("hsv_saturation", &QColor::hsvSaturation)
+            .define_method("hsv_saturation_f", &QColor::hsvSaturationF)
+            .define_method("hue", &QColor::hue)
+            .define_method("hue_f", &QColor::hueF)
+            .define_method("valid?", &QColor::isValid)
+            .define_method("lighter", &QColor::lighter, Arg("f") = static_cast<int>(150))
+            .define_method("lightness", &QColor::lightness)
+            .define_method("lightness_f", &QColor::lightnessF)
+            .define_method("magenta", &QColor::magenta)
+            .define_method("magenta_f", &QColor::magentaF)
+            .define_method("name", &QColor::name, Arg("format") = static_cast<QColor::NameFormat>(QColor::NameFormat::HexRgb))
+            .define_method("red", &QColor::red)
+            .define_method("red_f", &QColor::redF)
+            .define_method("rgb", &QColor::rgb)
+            .define_method("rgba", &QColor::rgba)
+            .define_method("rgba64", &QColor::rgba64)
+            .define_method("saturation", &QColor::saturation)
+            .define_method("saturation_f", &QColor::saturationF)
+            .define_method("set_alpha", &QColor::setAlpha, Arg("alpha"))
+            .define_method("set_alpha_f", &QColor::setAlphaF, Arg("alpha"))
+            .define_method("set_blue", &QColor::setBlue, Arg("blue"))
+            .define_method("set_blue_f", &QColor::setBlueF, Arg("blue"))
+            .define_method("set_cmyk", &QColor::setCmyk, Arg("c"), Arg("m"), Arg("y"), Arg("k"), Arg("a") = static_cast<int>(255))
+            .define_method("set_cmyk_f", &QColor::setCmykF, Arg("c"), Arg("m"), Arg("y"), Arg("k"), Arg("a") = static_cast<float>(1.0))
+            .define_method("set_green", &QColor::setGreen, Arg("green"))
+            .define_method("set_green_f", &QColor::setGreenF, Arg("green"))
+            .define_method("set_hsl", &QColor::setHsl, Arg("h"), Arg("s"), Arg("l"), Arg("a") = static_cast<int>(255))
+            .define_method("set_hsl_f", &QColor::setHslF, Arg("h"), Arg("s"), Arg("l"), Arg("a") = static_cast<float>(1.0))
+            .define_method("set_hsv", &QColor::setHsv, Arg("h"), Arg("s"), Arg("v"), Arg("a") = static_cast<int>(255))
+            .define_method("set_hsv_f", &QColor::setHsvF, Arg("h"), Arg("s"), Arg("v"), Arg("a") = static_cast<float>(1.0))
+            .define_method("set_red", &QColor::setRed, Arg("red"))
+            .define_method("set_red_f", &QColor::setRedF, Arg("red"))
+            .define_method<void (QColor::*)(QRgb) noexcept>("set_rgb", &QColor::setRgb, Arg("rgb"))
+            .define_method<void (QColor::*)(int, int, int, int)>("set_rgb", &QColor::setRgb, Arg("r"), Arg("g"), Arg("b"), Arg("a") = static_cast<int>(255))
+            .define_method("set_rgb_f", &QColor::setRgbF, Arg("r"), Arg("g"), Arg("b"), Arg("a") = static_cast<float>(1.0))
+            .define_method("set_rgba", &QColor::setRgba, Arg("rgba"))
+            .define_method("set_rgba64", &QColor::setRgba64, Arg("rgba"))
+            .define_method("spec", &QColor::spec)
+            .define_method("to_cmyk", &QColor::toCmyk)
+            .define_method("to_extended_rgb", &QColor::toExtendedRgb)
+            .define_method("to_hsl", &QColor::toHsl)
+            .define_method("to_hsv", &QColor::toHsv)
+            .define_method("to_rgb", &QColor::toRgb)
+            .define_method("value", &QColor::value)
+            .define_method("value_f", &QColor::valueF)
+            .define_method("yellow", &QColor::yellow)
+            .define_method("yellow_f", &QColor::yellowF)
+            // Static Public Members
+            .define_singleton_function("color_names", &QColor::colorNames)
+            .define_singleton_function("from_cmyk", &QColor::fromCmyk, Arg("c"), Arg("m"), Arg("y"), Arg("k"), Arg("a") = static_cast<int>(255))
+            .define_singleton_function("from_cmyk_f", &QColor::fromCmykF, Arg("c"), Arg("m"), Arg("y"), Arg("k"), Arg("a") = static_cast<float>(1.0))
+            .define_singleton_function("from_hsl", &QColor::fromHsl, Arg("h"), Arg("s"), Arg("l"), Arg("a") = static_cast<int>(255))
+            .define_singleton_function("from_hsl_f", &QColor::fromHslF, Arg("h"), Arg("s"), Arg("l"), Arg("a") = static_cast<float>(1.0))
+            .define_singleton_function("from_hsv", &QColor::fromHsv, Arg("h"), Arg("s"), Arg("v"), Arg("a") = static_cast<int>(255))
+            .define_singleton_function("from_hsv_f", &QColor::fromHsvF, Arg("h"), Arg("s"), Arg("v"), Arg("a") = static_cast<float>(1.0))
+            .define_singleton_function<QColor (*)(QRgb)>("from_rgb", &QColor::fromRgb, Arg("rgb"))
+            .define_singleton_function<QColor (*)(int, int, int, int)>("from_rgb", &QColor::fromRgb, Arg("r"), Arg("g"), Arg("b"), Arg("a") = static_cast<int>(255))
+            .define_singleton_function("from_rgb_f", &QColor::fromRgbF, Arg("r"), Arg("g"), Arg("b"), Arg("a") = static_cast<float>(1.0));
+
+    Data_Type<QColor::NameFormat> rb_cQColorNameFormat =
+        // RubyQt6::QtGui::QColor::NameFormat
+        define_qenum_under<QColor::NameFormat>(rb_cQColor, "NameFormat");
+        define_qenum_value_under(rb_cQColorNameFormat, "HexRgb", QColor::NameFormat::HexRgb);
+        define_qenum_value_under(rb_cQColorNameFormat, "HexArgb", QColor::NameFormat::HexArgb);
+
+    Data_Type<QColor::Spec> rb_cQColorSpec =
+        // RubyQt6::QtGui::QColor::Spec
+        define_qenum_under<QColor::Spec>(rb_cQColor, "Spec");
+        define_qenum_value_under(rb_cQColorSpec, "Invalid", QColor::Spec::Invalid);
+        define_qenum_value_under(rb_cQColorSpec, "Rgb", QColor::Spec::Rgb);
+        define_qenum_value_under(rb_cQColorSpec, "Hsv", QColor::Spec::Hsv);
+        define_qenum_value_under(rb_cQColorSpec, "Cmyk", QColor::Spec::Cmyk);
+        define_qenum_value_under(rb_cQColorSpec, "Hsl", QColor::Spec::Hsl);
+        define_qenum_value_under(rb_cQColorSpec, "ExtendedRgb", QColor::Spec::ExtendedRgb);
+}

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

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

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

@@ -0,0 +1,32 @@
+#include "qcursor-rb.hpp"
+#include <qcursor.h>
+
+#include <QScreen>
+
+using namespace Rice;
+
+Rice::Class rb_cQCursor;
+
+void Init_qcursor(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQCursor =
+        // RubyQt6::QtGui::QCursor
+        define_class_under<QCursor>(rb_mQt6QtGui, "QCursor")
+            // Constructor
+            .define_constructor(Constructor<QCursor>())
+            .define_constructor(Constructor<QCursor, Qt::CursorShape>(), Arg("shape"))
+            // Public Functions
+            .define_method<QBitmap (QCursor::*)() const>("bitmap", &QCursor::bitmap)
+            .define_method("hot_spot", &QCursor::hotSpot)
+            .define_method<QBitmap (QCursor::*)() const>("mask", &QCursor::mask)
+            .define_method("pixmap", &QCursor::pixmap)
+            .define_method("set_shape", &QCursor::setShape, Arg("new_shape"))
+            .define_method("shape", &QCursor::shape)
+            // Static Public Members
+            .define_singleton_function<QPoint (*)()>("pos", &QCursor::pos)
+            .define_singleton_function<QPoint (*)(const QScreen *)>("pos", &QCursor::pos, Arg("screen"))
+            .define_singleton_function<void (*)(QScreen *, const QPoint &)>("set_pos", &QCursor::setPos, Arg("screen"), Arg("p"))
+            .define_singleton_function<void (*)(QScreen *, int, int)>("set_pos", &QCursor::setPos, Arg("screen"), Arg("x"), Arg("y"))
+            .define_singleton_function<void (*)(const QPoint &)>("set_pos", &QCursor::setPos, Arg("p"))
+            .define_singleton_function<void (*)(int, int)>("set_pos", &QCursor::setPos, Arg("x"), Arg("y"));
+}

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

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

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

@@ -0,0 +1,399 @@
+#include "qevent-rb.hpp"
+#include <qevent.h>
+
+#include <QAction>
+#include <QFile>
+#include <QList>
+#include <QMimeData>
+#include <QPointer>
+#include <QWindow>
+
+using namespace Rice;
+
+Rice::Class rb_cQActionEvent;
+Rice::Class rb_cQApplicationStateChangeEvent;
+Rice::Class rb_cQChildWindowEvent;
+Rice::Class rb_cQCloseEvent;
+Rice::Class rb_cQDragLeaveEvent;
+Rice::Class rb_cQDropEvent;
+Rice::Class rb_cQDragMoveEvent;
+Rice::Class rb_cQDragEnterEvent;
+Rice::Class rb_cQExposeEvent;
+Rice::Class rb_cQFileOpenEvent;
+Rice::Class rb_cQFocusEvent;
+Rice::Class rb_cQHelpEvent;
+Rice::Class rb_cQHideEvent;
+Rice::Class rb_cQIconDragEvent;
+Rice::Class rb_cQInputEvent;
+Rice::Class rb_cQInputMethodEvent;
+Rice::Class rb_cQInputMethodQueryEvent;
+Rice::Class rb_cQMoveEvent;
+Rice::Class rb_cQPaintEvent;
+Rice::Class rb_cQPlatformSurfaceEvent;
+Rice::Class rb_cQResizeEvent;
+Rice::Class rb_cQScreenOrientationChangeEvent;
+Rice::Class rb_cQScrollEvent;
+Rice::Class rb_cQScrollPrepareEvent;
+Rice::Class rb_cQShortcutEvent;
+Rice::Class rb_cQShowEvent;
+Rice::Class rb_cQStatusTipEvent;
+Rice::Class rb_cQToolBarChangeEvent;
+Rice::Class rb_cQWhatsThisClickedEvent;
+Rice::Class rb_cQWindowStateChangeEvent;
+Rice::Class rb_cQContextMenuEvent;
+Rice::Class rb_cQKeyEvent;
+Rice::Class rb_cQPointerEvent;
+Rice::Class rb_cQSinglePointEvent;
+Rice::Class rb_cQEnterEvent;
+Rice::Class rb_cQHoverEvent;
+Rice::Class rb_cQMouseEvent;
+Rice::Class rb_cQNativeGestureEvent;
+Rice::Class rb_cQTabletEvent;
+Rice::Class rb_cQWheelEvent;
+Rice::Class rb_cQTouchEvent;
+
+void Init_qevent(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQActionEvent =
+        // RubyQt6::QtGui::QActionEvent
+        define_class_under<QActionEvent, QEvent>(rb_mQt6QtGui, "QActionEvent")
+            // Public Functions
+            .define_method("action", &QActionEvent::action)
+            .define_method("before", &QActionEvent::before);
+
+    rb_cQApplicationStateChangeEvent =
+        // RubyQt6::QtGui::QApplicationStateChangeEvent
+        define_class_under<QApplicationStateChangeEvent, QEvent>(rb_mQt6QtGui, "QApplicationStateChangeEvent")
+            // Public Functions
+            .define_method("application_state", &QApplicationStateChangeEvent::applicationState);
+
+    rb_cQChildWindowEvent =
+        // RubyQt6::QtGui::QChildWindowEvent
+        define_class_under<QChildWindowEvent, QEvent>(rb_mQt6QtGui, "QChildWindowEvent")
+            // Public Functions
+            .define_method("child", &QChildWindowEvent::child);
+
+    rb_cQCloseEvent =
+        // RubyQt6::QtGui::QCloseEvent
+        define_class_under<QCloseEvent, QEvent>(rb_mQt6QtGui, "QCloseEvent");
+
+    rb_cQDragLeaveEvent =
+        // RubyQt6::QtGui::QDragLeaveEvent
+        define_class_under<QDragLeaveEvent, QEvent>(rb_mQt6QtGui, "QDragLeaveEvent");
+
+    rb_cQDropEvent =
+        // RubyQt6::QtGui::QDropEvent
+        define_class_under<QDropEvent, QEvent>(rb_mQt6QtGui, "QDropEvent")
+            // Public Functions
+            .define_method("accept_proposed_action", &QDropEvent::acceptProposedAction)
+            .define_method("buttons", &QDropEvent::buttons)
+            .define_method("drop_action", &QDropEvent::dropAction)
+            .define_method("mime_data", &QDropEvent::mimeData)
+            .define_method("modifiers", &QDropEvent::modifiers)
+            .define_method("position", &QDropEvent::position)
+            .define_method("possible_actions", &QDropEvent::possibleActions)
+            .define_method("proposed_action", &QDropEvent::proposedAction)
+            .define_method("set_drop_action", &QDropEvent::setDropAction, Arg("action"))
+            .define_method("source", &QDropEvent::source);
+
+    rb_cQDragMoveEvent =
+        // RubyQt6::QtGui::QDragMoveEvent
+        define_class_under<QDragMoveEvent, QDropEvent>(rb_mQt6QtGui, "QDragMoveEvent")
+            // Public Functions
+            .define_method<void (QDragMoveEvent::*)()>("accept", &QDragMoveEvent::accept)
+            .define_method<void (QDragMoveEvent::*)(const QRect &)>("accept", &QDragMoveEvent::accept, Arg("r"))
+            .define_method("answer_rect", &QDragMoveEvent::answerRect)
+            .define_method<void (QDragMoveEvent::*)()>("ignore", &QDragMoveEvent::ignore)
+            .define_method<void (QDragMoveEvent::*)(const QRect &)>("ignore", &QDragMoveEvent::ignore, Arg("r"));
+
+    rb_cQDragEnterEvent =
+        // RubyQt6::QtGui::QDragEnterEvent
+        define_class_under<QDragEnterEvent, QDragMoveEvent>(rb_mQt6QtGui, "QDragEnterEvent");
+
+    rb_cQExposeEvent =
+        // RubyQt6::QtGui::QExposeEvent
+        define_class_under<QExposeEvent, QEvent>(rb_mQt6QtGui, "QExposeEvent");
+
+    rb_cQFileOpenEvent =
+        // RubyQt6::QtGui::QFileOpenEvent
+        define_class_under<QFileOpenEvent, QEvent>(rb_mQt6QtGui, "QFileOpenEvent")
+            // Public Functions
+            .define_method("file", &QFileOpenEvent::file)
+            .define_method("url", &QFileOpenEvent::url);
+
+    rb_cQFocusEvent =
+        // RubyQt6::QtGui::QFocusEvent
+        define_class_under<QFocusEvent, QEvent>(rb_mQt6QtGui, "QFocusEvent")
+            // Public Functions
+            .define_method("got_focus", &QFocusEvent::gotFocus)
+            .define_method("lost_focus", &QFocusEvent::lostFocus)
+            .define_method("reason", &QFocusEvent::reason);
+
+    rb_cQHelpEvent =
+        // RubyQt6::QtGui::QHelpEvent
+        define_class_under<QHelpEvent, QEvent>(rb_mQt6QtGui, "QHelpEvent")
+            // Public Functions
+            .define_method("global_pos", &QHelpEvent::globalPos)
+            .define_method("global_x", &QHelpEvent::globalX)
+            .define_method("global_y", &QHelpEvent::globalY)
+            .define_method("pos", &QHelpEvent::pos)
+            .define_method("x", &QHelpEvent::x)
+            .define_method("y", &QHelpEvent::y);
+
+    rb_cQHideEvent =
+        // RubyQt6::QtGui::QHideEvent
+        define_class_under<QHideEvent, QEvent>(rb_mQt6QtGui, "QHideEvent");
+
+    rb_cQIconDragEvent =
+        // RubyQt6::QtGui::QIconDragEvent
+        define_class_under<QIconDragEvent, QEvent>(rb_mQt6QtGui, "QIconDragEvent");
+
+    rb_cQInputEvent =
+        // RubyQt6::QtGui::QInputEvent
+        define_class_under<QInputEvent, QEvent>(rb_mQt6QtGui, "QInputEvent")
+            // Public Functions
+            .define_method("device", &QInputEvent::device)
+            .define_method("device_type", &QInputEvent::deviceType)
+            .define_method("modifiers", &QInputEvent::modifiers)
+            .define_method("set_modifiers", &QInputEvent::setModifiers, Arg("modifiers"))
+            .define_method("set_timestamp", &QInputEvent::setTimestamp, Arg("timestamp"))
+            .define_method("timestamp", &QInputEvent::timestamp);
+
+    rb_cQInputMethodEvent =
+        // RubyQt6::QtGui::QInputMethodEvent
+        define_class_under<QInputMethodEvent, QEvent>(rb_mQt6QtGui, "QInputMethodEvent")
+            // Public Functions
+            .define_method("attributes", &QInputMethodEvent::attributes)
+            .define_method("commit_string", &QInputMethodEvent::commitString)
+            .define_method("preedit_string", &QInputMethodEvent::preeditString)
+            .define_method("replacement_start", &QInputMethodEvent::replacementStart)
+            .define_method("replacement_length", &QInputMethodEvent::replacementLength)
+            .define_method("set_commit_string", &QInputMethodEvent::setCommitString, Arg("commit_string"), Arg("replace_from") = static_cast<int>(0), Arg("replace_length") = static_cast<int>(0));
+
+    rb_cQInputMethodQueryEvent =
+        // RubyQt6::QtGui::QInputMethodQueryEvent
+        define_class_under<QInputMethodQueryEvent, QEvent>(rb_mQt6QtGui, "QInputMethodQueryEvent")
+            // Public Functions
+            .define_method("queries", &QInputMethodQueryEvent::queries)
+            .define_method("set_value", &QInputMethodQueryEvent::setValue, Arg("query"), Arg("value"))
+            .define_method("value", &QInputMethodQueryEvent::value, Arg("query"));
+
+    rb_cQMoveEvent =
+        // RubyQt6::QtGui::QMoveEvent
+        define_class_under<QMoveEvent, QEvent>(rb_mQt6QtGui, "QMoveEvent")
+            // Public Functions
+            .define_method("old_pos", &QMoveEvent::oldPos)
+            .define_method("pos", &QMoveEvent::pos);
+
+    rb_cQPaintEvent =
+        // RubyQt6::QtGui::QPaintEvent
+        define_class_under<QPaintEvent, QEvent>(rb_mQt6QtGui, "QPaintEvent")
+            // Public Functions
+            .define_method("rect", &QPaintEvent::rect)
+            .define_method("region", &QPaintEvent::region);
+
+    rb_cQPlatformSurfaceEvent =
+        // RubyQt6::QtGui::QPlatformSurfaceEvent
+        define_class_under<QPlatformSurfaceEvent, QEvent>(rb_mQt6QtGui, "QPlatformSurfaceEvent");
+
+    rb_cQResizeEvent =
+        // RubyQt6::QtGui::QResizeEvent
+        define_class_under<QResizeEvent, QEvent>(rb_mQt6QtGui, "QResizeEvent")
+            // Public Functions
+            .define_method("old_size", &QResizeEvent::oldSize)
+            .define_method("size", &QResizeEvent::size);
+
+    rb_cQScreenOrientationChangeEvent =
+        // RubyQt6::QtGui::QScreenOrientationChangeEvent
+        define_class_under<QScreenOrientationChangeEvent, QEvent>(rb_mQt6QtGui, "QScreenOrientationChangeEvent")
+            // Public Functions
+            .define_method("orientation", &QScreenOrientationChangeEvent::orientation)
+            .define_method("screen", &QScreenOrientationChangeEvent::screen);
+
+    rb_cQScrollEvent =
+        // RubyQt6::QtGui::QScrollEvent
+        define_class_under<QScrollEvent, QEvent>(rb_mQt6QtGui, "QScrollEvent")
+            // Public Functions
+            .define_method("content_pos", &QScrollEvent::contentPos)
+            .define_method("overshoot_distance", &QScrollEvent::overshootDistance)
+            .define_method("scroll_state", &QScrollEvent::scrollState);
+
+    rb_cQScrollPrepareEvent =
+        // RubyQt6::QtGui::QScrollPrepareEvent
+        define_class_under<QScrollPrepareEvent, QEvent>(rb_mQt6QtGui, "QScrollPrepareEvent")
+            // Public Functions
+            .define_method("content_pos", &QScrollPrepareEvent::contentPos)
+            .define_method("content_pos_range", &QScrollPrepareEvent::contentPosRange)
+            .define_method("set_content_pos", &QScrollPrepareEvent::setContentPos, Arg("pos"))
+            .define_method("set_content_pos_range", &QScrollPrepareEvent::setContentPosRange, Arg("rect"))
+            .define_method("set_viewport_size", &QScrollPrepareEvent::setViewportSize, Arg("size"))
+            .define_method("start_pos", &QScrollPrepareEvent::startPos)
+            .define_method("viewport_size", &QScrollPrepareEvent::viewportSize);
+
+    rb_cQShortcutEvent =
+        // RubyQt6::QtGui::QShortcutEvent
+        define_class_under<QShortcutEvent, QEvent>(rb_mQt6QtGui, "QShortcutEvent")
+            // Public Functions
+            .define_method("ambiguous?", &QShortcutEvent::isAmbiguous)
+            .define_method("key", &QShortcutEvent::key)
+            .define_method("shortcut_id", &QShortcutEvent::shortcutId);
+
+    rb_cQShowEvent =
+        // RubyQt6::QtGui::QShowEvent
+        define_class_under<QShowEvent, QEvent>(rb_mQt6QtGui, "QShowEvent");
+
+    rb_cQStatusTipEvent =
+        // RubyQt6::QtGui::QStatusTipEvent
+        define_class_under<QStatusTipEvent, QEvent>(rb_mQt6QtGui, "QStatusTipEvent")
+            // Public Functions
+            .define_method("tip", &QStatusTipEvent::tip);
+
+    rb_cQToolBarChangeEvent =
+        // RubyQt6::QtGui::QToolBarChangeEvent
+        define_class_under<QToolBarChangeEvent, QEvent>(rb_mQt6QtGui, "QToolBarChangeEvent")
+            // Public Functions
+            .define_method("toggle", &QToolBarChangeEvent::toggle);
+
+    rb_cQWhatsThisClickedEvent =
+        // RubyQt6::QtGui::QWhatsThisClickedEvent
+        define_class_under<QWhatsThisClickedEvent, QEvent>(rb_mQt6QtGui, "QWhatsThisClickedEvent")
+            // Public Functions
+            .define_method("href", &QWhatsThisClickedEvent::href);
+
+    rb_cQWindowStateChangeEvent =
+        // RubyQt6::QtGui::QWindowStateChangeEvent
+        define_class_under<QWindowStateChangeEvent, QEvent>(rb_mQt6QtGui, "QWindowStateChangeEvent")
+            // Public Functions
+            .define_method("override?", &QWindowStateChangeEvent::isOverride)
+            .define_method("old_state", &QWindowStateChangeEvent::oldState);
+
+    rb_cQContextMenuEvent =
+        // RubyQt6::QtGui::QContextMenuEvent
+        define_class_under<QContextMenuEvent, QInputEvent>(rb_mQt6QtGui, "QContextMenuEvent")
+            // Public Functions
+            .define_method("global_pos", &QContextMenuEvent::globalPos)
+            .define_method("global_x", &QContextMenuEvent::globalX)
+            .define_method("global_y", &QContextMenuEvent::globalY)
+            .define_method("pos", &QContextMenuEvent::pos)
+            .define_method("x", &QContextMenuEvent::x)
+            .define_method("y", &QContextMenuEvent::y)
+            .define_method("reason", &QContextMenuEvent::reason);
+
+    rb_cQKeyEvent =
+        // RubyQt6::QtGui::QKeyEvent
+        define_class_under<QKeyEvent, QInputEvent>(rb_mQt6QtGui, "QKeyEvent")
+            // Public Functions
+            .define_method("count", &QKeyEvent::count)
+            .define_method("auto_repeat?", &QKeyEvent::isAutoRepeat)
+            .define_method("key", &QKeyEvent::key)
+            .define_method("key_combination", &QKeyEvent::keyCombination)
+            .define_method("matches", &QKeyEvent::matches, Arg("key"))
+            .define_method("modifiers", &QKeyEvent::modifiers)
+            .define_method("native_scan_code", &QKeyEvent::nativeScanCode)
+            .define_method("native_virtual_key", &QKeyEvent::nativeVirtualKey)
+            .define_method("native_modifiers", &QKeyEvent::nativeModifiers)
+            .define_method("text", &QKeyEvent::text);
+
+    rb_cQPointerEvent =
+        // RubyQt6::QtGui::QPointerEvent
+        define_class_under<QPointerEvent, QInputEvent>(rb_mQt6QtGui, "QPointerEvent")
+            // Public Functions
+            .define_method("add_passive_grabber", &QPointerEvent::addPassiveGrabber, Arg("point"), Arg("grabber"))
+            .define_method("all_points_accepted", &QPointerEvent::allPointsAccepted)
+            .define_method("all_points_grabbed", &QPointerEvent::allPointsGrabbed)
+            .define_method("clear_passive_grabbers", &QPointerEvent::clearPassiveGrabbers, Arg("point"))
+            .define_method("exclusive_grabber", &QPointerEvent::exclusiveGrabber, Arg("point"))
+            .define_method("begin_event?", &QPointerEvent::isBeginEvent)
+            .define_method("end_event?", &QPointerEvent::isEndEvent)
+            .define_method("update_event?", &QPointerEvent::isUpdateEvent)
+            .define_method("passive_grabbers", &QPointerEvent::passiveGrabbers, Arg("point"))
+            .define_method("point", &QPointerEvent::point, Arg("i"))
+            .define_method("point_by_id", &QPointerEvent::pointById, Arg("id"))
+            .define_method("point_count", &QPointerEvent::pointCount)
+            .define_method("pointer_type", &QPointerEvent::pointerType)
+            .define_method("pointing_device", &QPointerEvent::pointingDevice)
+            .define_method("points", &QPointerEvent::points)
+            .define_method("remove_passive_grabber", &QPointerEvent::removePassiveGrabber, Arg("point"), Arg("grabber"))
+            .define_method("set_accepted", &QPointerEvent::setAccepted, Arg("accepted"))
+            .define_method("set_exclusive_grabber", &QPointerEvent::setExclusiveGrabber, Arg("point"), Arg("exclusive_grabber"))
+            .define_method("set_timestamp", &QPointerEvent::setTimestamp, Arg("timestamp"));
+
+    rb_cQSinglePointEvent =
+        // RubyQt6::QtGui::QSinglePointEvent
+        define_class_under<QSinglePointEvent, QPointerEvent>(rb_mQt6QtGui, "QSinglePointEvent")
+            // Public Functions
+            .define_method("button", &QSinglePointEvent::button)
+            .define_method("buttons", &QSinglePointEvent::buttons)
+            .define_method("exclusive_point_grabber", &QSinglePointEvent::exclusivePointGrabber)
+            .define_method("global_position", &QSinglePointEvent::globalPosition)
+            .define_method("begin_event?", &QSinglePointEvent::isBeginEvent)
+            .define_method("end_event?", &QSinglePointEvent::isEndEvent)
+            .define_method("update_event?", &QSinglePointEvent::isUpdateEvent)
+            .define_method("position", &QSinglePointEvent::position)
+            .define_method("scene_position", &QSinglePointEvent::scenePosition)
+            .define_method("set_exclusive_point_grabber", &QSinglePointEvent::setExclusivePointGrabber, Arg("exclusive_grabber"));
+
+    rb_cQEnterEvent =
+        // RubyQt6::QtGui::QEnterEvent
+        define_class_under<QEnterEvent, QSinglePointEvent>(rb_mQt6QtGui, "QEnterEvent");
+
+    rb_cQHoverEvent =
+        // RubyQt6::QtGui::QHoverEvent
+        define_class_under<QHoverEvent, QSinglePointEvent>(rb_mQt6QtGui, "QHoverEvent")
+            // Public Functions
+            .define_method("old_pos", &QHoverEvent::oldPos)
+            .define_method("old_pos_f", &QHoverEvent::oldPosF)
+            .define_method("update_event?", &QHoverEvent::isUpdateEvent);
+
+    rb_cQMouseEvent =
+        // RubyQt6::QtGui::QMouseEvent
+        define_class_under<QMouseEvent, QSinglePointEvent>(rb_mQt6QtGui, "QMouseEvent")
+            // Public Functions
+            .define_method("source", &QMouseEvent::source)
+            .define_method("flags", &QMouseEvent::flags);
+
+    rb_cQNativeGestureEvent =
+        // RubyQt6::QtGui::QNativeGestureEvent
+        define_class_under<QNativeGestureEvent, QSinglePointEvent>(rb_mQt6QtGui, "QNativeGestureEvent")
+            // Public Functions
+            .define_method("delta", &QNativeGestureEvent::delta)
+            .define_method("finger_count", &QNativeGestureEvent::fingerCount)
+            .define_method("gesture_type", &QNativeGestureEvent::gestureType)
+            .define_method("value", &QNativeGestureEvent::value);
+
+    rb_cQTabletEvent =
+        // RubyQt6::QtGui::QTabletEvent
+        define_class_under<QTabletEvent, QSinglePointEvent>(rb_mQt6QtGui, "QTabletEvent")
+            // Public Functions
+            .define_method("pressure", &QTabletEvent::pressure)
+            .define_method("rotation", &QTabletEvent::rotation)
+            .define_method("tangential_pressure", &QTabletEvent::tangentialPressure)
+            .define_method("x_tilt", &QTabletEvent::xTilt)
+            .define_method("y_tilt", &QTabletEvent::yTilt)
+            .define_method("z", &QTabletEvent::z);
+
+    rb_cQWheelEvent =
+        // RubyQt6::QtGui::QWheelEvent
+        define_class_under<QWheelEvent, QSinglePointEvent>(rb_mQt6QtGui, "QWheelEvent")
+            // Public Functions
+            .define_method("angle_delta", &QWheelEvent::angleDelta)
+            .define_method("has_pixel_delta", &QWheelEvent::hasPixelDelta)
+            .define_method("inverted", &QWheelEvent::inverted)
+            .define_method("begin_event?", &QWheelEvent::isBeginEvent)
+            .define_method("end_event?", &QWheelEvent::isEndEvent)
+            .define_method("inverted?", &QWheelEvent::isInverted)
+            .define_method("update_event?", &QWheelEvent::isUpdateEvent)
+            .define_method("phase", &QWheelEvent::phase)
+            .define_method("pixel_delta", &QWheelEvent::pixelDelta)
+            .define_method("source", &QWheelEvent::source);
+
+    rb_cQTouchEvent =
+        // RubyQt6::QtGui::QTouchEvent
+        define_class_under<QTouchEvent, QPointerEvent>(rb_mQt6QtGui, "QTouchEvent")
+            // Public Functions
+            .define_method("begin_event?", &QTouchEvent::isBeginEvent)
+            .define_method("end_event?", &QTouchEvent::isEndEvent)
+            .define_method("update_event?", &QTouchEvent::isUpdateEvent)
+            .define_method("target", &QTouchEvent::target)
+            .define_method("touch_point_states", &QTouchEvent::touchPointStates);
+}

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

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