ruby-qt6-qtcore 1.0.0

data/ext/qt6/qtcore/qcoreevent-rb.cpp

@@ -0,0 +1,234 @@
+#include "qcoreevent-rb.hpp"
+#include <qcoreevent.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQEvent;
+Rice::Class rb_cQChildEvent;
+Rice::Class rb_cQTimerEvent;
+Rice::Class rb_cQDynamicPropertyChangeEvent;
+
+void Init_qcoreevent(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQEvent =
+        // RubyQt6::QtCore::QEvent
+        define_class_under<QEvent>(rb_mQt6QtCore, "QEvent")
+            // Public Functions
+            .define_method("accept", &QEvent::accept)
+            .define_method("clone", &QEvent::clone)
+            .define_method("ignore", &QEvent::ignore)
+            .define_method("accepted?", &QEvent::isAccepted)
+            .define_method("input_event?", &QEvent::isInputEvent)
+            .define_method("pointer_event?", &QEvent::isPointerEvent)
+            .define_method("single_point_event?", &QEvent::isSinglePointEvent)
+            .define_method("set_accepted", &QEvent::setAccepted, Arg("accepted"))
+            .define_method("spontaneous", &QEvent::spontaneous)
+            .define_method("type", &QEvent::type);
+
+    Data_Type<QEvent::Type> rb_cQEventType =
+        // RubyQt6::QtCore::QEvent::Type
+        define_qenum_under<QEvent::Type>(rb_cQEvent, "Type");
+        define_qenum_value_under(rb_cQEventType, "None", QEvent::Type::None);
+        define_qenum_value_under(rb_cQEventType, "Timer", QEvent::Type::Timer);
+        define_qenum_value_under(rb_cQEventType, "MouseButtonPress", QEvent::Type::MouseButtonPress);
+        define_qenum_value_under(rb_cQEventType, "MouseButtonRelease", QEvent::Type::MouseButtonRelease);
+        define_qenum_value_under(rb_cQEventType, "MouseButtonDblClick", QEvent::Type::MouseButtonDblClick);
+        define_qenum_value_under(rb_cQEventType, "MouseMove", QEvent::Type::MouseMove);
+        define_qenum_value_under(rb_cQEventType, "KeyPress", QEvent::Type::KeyPress);
+        define_qenum_value_under(rb_cQEventType, "KeyRelease", QEvent::Type::KeyRelease);
+        define_qenum_value_under(rb_cQEventType, "FocusIn", QEvent::Type::FocusIn);
+        define_qenum_value_under(rb_cQEventType, "FocusOut", QEvent::Type::FocusOut);
+        define_qenum_value_under(rb_cQEventType, "FocusAboutToChange", QEvent::Type::FocusAboutToChange);
+        define_qenum_value_under(rb_cQEventType, "Enter", QEvent::Type::Enter);
+        define_qenum_value_under(rb_cQEventType, "Leave", QEvent::Type::Leave);
+        define_qenum_value_under(rb_cQEventType, "Paint", QEvent::Type::Paint);
+        define_qenum_value_under(rb_cQEventType, "Move", QEvent::Type::Move);
+        define_qenum_value_under(rb_cQEventType, "Resize", QEvent::Type::Resize);
+        define_qenum_value_under(rb_cQEventType, "Create", QEvent::Type::Create);
+        define_qenum_value_under(rb_cQEventType, "Destroy", QEvent::Type::Destroy);
+        define_qenum_value_under(rb_cQEventType, "Show", QEvent::Type::Show);
+        define_qenum_value_under(rb_cQEventType, "Hide", QEvent::Type::Hide);
+        define_qenum_value_under(rb_cQEventType, "Close", QEvent::Type::Close);
+        define_qenum_value_under(rb_cQEventType, "Quit", QEvent::Type::Quit);
+        define_qenum_value_under(rb_cQEventType, "ParentChange", QEvent::Type::ParentChange);
+        define_qenum_value_under(rb_cQEventType, "ParentAboutToChange", QEvent::Type::ParentAboutToChange);
+        define_qenum_value_under(rb_cQEventType, "ThreadChange", QEvent::Type::ThreadChange);
+        define_qenum_value_under(rb_cQEventType, "WindowActivate", QEvent::Type::WindowActivate);
+        define_qenum_value_under(rb_cQEventType, "WindowDeactivate", QEvent::Type::WindowDeactivate);
+        define_qenum_value_under(rb_cQEventType, "ShowToParent", QEvent::Type::ShowToParent);
+        define_qenum_value_under(rb_cQEventType, "HideToParent", QEvent::Type::HideToParent);
+        define_qenum_value_under(rb_cQEventType, "Wheel", QEvent::Type::Wheel);
+        define_qenum_value_under(rb_cQEventType, "WindowTitleChange", QEvent::Type::WindowTitleChange);
+        define_qenum_value_under(rb_cQEventType, "WindowIconChange", QEvent::Type::WindowIconChange);
+        define_qenum_value_under(rb_cQEventType, "ApplicationWindowIconChange", QEvent::Type::ApplicationWindowIconChange);
+        define_qenum_value_under(rb_cQEventType, "ApplicationFontChange", QEvent::Type::ApplicationFontChange);
+        define_qenum_value_under(rb_cQEventType, "ApplicationLayoutDirectionChange", QEvent::Type::ApplicationLayoutDirectionChange);
+        define_qenum_value_under(rb_cQEventType, "ApplicationPaletteChange", QEvent::Type::ApplicationPaletteChange);
+        define_qenum_value_under(rb_cQEventType, "PaletteChange", QEvent::Type::PaletteChange);
+        define_qenum_value_under(rb_cQEventType, "Clipboard", QEvent::Type::Clipboard);
+        define_qenum_value_under(rb_cQEventType, "Speech", QEvent::Type::Speech);
+        define_qenum_value_under(rb_cQEventType, "MetaCall", QEvent::Type::MetaCall);
+        define_qenum_value_under(rb_cQEventType, "SockAct", QEvent::Type::SockAct);
+        define_qenum_value_under(rb_cQEventType, "WinEventAct", QEvent::Type::WinEventAct);
+        define_qenum_value_under(rb_cQEventType, "DeferredDelete", QEvent::Type::DeferredDelete);
+        define_qenum_value_under(rb_cQEventType, "DragEnter", QEvent::Type::DragEnter);
+        define_qenum_value_under(rb_cQEventType, "DragMove", QEvent::Type::DragMove);
+        define_qenum_value_under(rb_cQEventType, "DragLeave", QEvent::Type::DragLeave);
+        define_qenum_value_under(rb_cQEventType, "Drop", QEvent::Type::Drop);
+        define_qenum_value_under(rb_cQEventType, "DragResponse", QEvent::Type::DragResponse);
+        define_qenum_value_under(rb_cQEventType, "ChildAdded", QEvent::Type::ChildAdded);
+        define_qenum_value_under(rb_cQEventType, "ChildPolished", QEvent::Type::ChildPolished);
+        define_qenum_value_under(rb_cQEventType, "ChildRemoved", QEvent::Type::ChildRemoved);
+        define_qenum_value_under(rb_cQEventType, "ShowWindowRequest", QEvent::Type::ShowWindowRequest);
+        define_qenum_value_under(rb_cQEventType, "PolishRequest", QEvent::Type::PolishRequest);
+        define_qenum_value_under(rb_cQEventType, "Polish", QEvent::Type::Polish);
+        define_qenum_value_under(rb_cQEventType, "LayoutRequest", QEvent::Type::LayoutRequest);
+        define_qenum_value_under(rb_cQEventType, "UpdateRequest", QEvent::Type::UpdateRequest);
+        define_qenum_value_under(rb_cQEventType, "UpdateLater", QEvent::Type::UpdateLater);
+        define_qenum_value_under(rb_cQEventType, "EmbeddingControl", QEvent::Type::EmbeddingControl);
+        define_qenum_value_under(rb_cQEventType, "ActivateControl", QEvent::Type::ActivateControl);
+        define_qenum_value_under(rb_cQEventType, "DeactivateControl", QEvent::Type::DeactivateControl);
+        define_qenum_value_under(rb_cQEventType, "ContextMenu", QEvent::Type::ContextMenu);
+        define_qenum_value_under(rb_cQEventType, "InputMethod", QEvent::Type::InputMethod);
+        define_qenum_value_under(rb_cQEventType, "TabletMove", QEvent::Type::TabletMove);
+        define_qenum_value_under(rb_cQEventType, "LocaleChange", QEvent::Type::LocaleChange);
+        define_qenum_value_under(rb_cQEventType, "LanguageChange", QEvent::Type::LanguageChange);
+        define_qenum_value_under(rb_cQEventType, "LayoutDirectionChange", QEvent::Type::LayoutDirectionChange);
+        define_qenum_value_under(rb_cQEventType, "Style", QEvent::Type::Style);
+        define_qenum_value_under(rb_cQEventType, "TabletPress", QEvent::Type::TabletPress);
+        define_qenum_value_under(rb_cQEventType, "TabletRelease", QEvent::Type::TabletRelease);
+        define_qenum_value_under(rb_cQEventType, "OkRequest", QEvent::Type::OkRequest);
+        define_qenum_value_under(rb_cQEventType, "HelpRequest", QEvent::Type::HelpRequest);
+        define_qenum_value_under(rb_cQEventType, "IconDrag", QEvent::Type::IconDrag);
+        define_qenum_value_under(rb_cQEventType, "FontChange", QEvent::Type::FontChange);
+        define_qenum_value_under(rb_cQEventType, "EnabledChange", QEvent::Type::EnabledChange);
+        define_qenum_value_under(rb_cQEventType, "ActivationChange", QEvent::Type::ActivationChange);
+        define_qenum_value_under(rb_cQEventType, "StyleChange", QEvent::Type::StyleChange);
+        define_qenum_value_under(rb_cQEventType, "IconTextChange", QEvent::Type::IconTextChange);
+        define_qenum_value_under(rb_cQEventType, "ModifiedChange", QEvent::Type::ModifiedChange);
+        define_qenum_value_under(rb_cQEventType, "MouseTrackingChange", QEvent::Type::MouseTrackingChange);
+        define_qenum_value_under(rb_cQEventType, "WindowBlocked", QEvent::Type::WindowBlocked);
+        define_qenum_value_under(rb_cQEventType, "WindowUnblocked", QEvent::Type::WindowUnblocked);
+        define_qenum_value_under(rb_cQEventType, "WindowStateChange", QEvent::Type::WindowStateChange);
+        define_qenum_value_under(rb_cQEventType, "ReadOnlyChange", QEvent::Type::ReadOnlyChange);
+        define_qenum_value_under(rb_cQEventType, "ToolTip", QEvent::Type::ToolTip);
+        define_qenum_value_under(rb_cQEventType, "WhatsThis", QEvent::Type::WhatsThis);
+        define_qenum_value_under(rb_cQEventType, "StatusTip", QEvent::Type::StatusTip);
+        define_qenum_value_under(rb_cQEventType, "ActionChanged", QEvent::Type::ActionChanged);
+        define_qenum_value_under(rb_cQEventType, "ActionAdded", QEvent::Type::ActionAdded);
+        define_qenum_value_under(rb_cQEventType, "ActionRemoved", QEvent::Type::ActionRemoved);
+        define_qenum_value_under(rb_cQEventType, "FileOpen", QEvent::Type::FileOpen);
+        define_qenum_value_under(rb_cQEventType, "Shortcut", QEvent::Type::Shortcut);
+        define_qenum_value_under(rb_cQEventType, "ShortcutOverride", QEvent::Type::ShortcutOverride);
+        define_qenum_value_under(rb_cQEventType, "WhatsThisClicked", QEvent::Type::WhatsThisClicked);
+        define_qenum_value_under(rb_cQEventType, "ToolBarChange", QEvent::Type::ToolBarChange);
+        define_qenum_value_under(rb_cQEventType, "ApplicationActivate", QEvent::Type::ApplicationActivate);
+        define_qenum_value_under(rb_cQEventType, "ApplicationActivated", QEvent::Type::ApplicationActivated);
+        define_qenum_value_under(rb_cQEventType, "ApplicationDeactivate", QEvent::Type::ApplicationDeactivate);
+        define_qenum_value_under(rb_cQEventType, "ApplicationDeactivated", QEvent::Type::ApplicationDeactivated);
+        define_qenum_value_under(rb_cQEventType, "QueryWhatsThis", QEvent::Type::QueryWhatsThis);
+        define_qenum_value_under(rb_cQEventType, "EnterWhatsThisMode", QEvent::Type::EnterWhatsThisMode);
+        define_qenum_value_under(rb_cQEventType, "LeaveWhatsThisMode", QEvent::Type::LeaveWhatsThisMode);
+        define_qenum_value_under(rb_cQEventType, "ZOrderChange", QEvent::Type::ZOrderChange);
+        define_qenum_value_under(rb_cQEventType, "HoverEnter", QEvent::Type::HoverEnter);
+        define_qenum_value_under(rb_cQEventType, "HoverLeave", QEvent::Type::HoverLeave);
+        define_qenum_value_under(rb_cQEventType, "HoverMove", QEvent::Type::HoverMove);
+        define_qenum_value_under(rb_cQEventType, "AcceptDropsChange", QEvent::Type::AcceptDropsChange);
+        define_qenum_value_under(rb_cQEventType, "ZeroTimerEvent", QEvent::Type::ZeroTimerEvent);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneMouseMove", QEvent::Type::GraphicsSceneMouseMove);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneMousePress", QEvent::Type::GraphicsSceneMousePress);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneMouseRelease", QEvent::Type::GraphicsSceneMouseRelease);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneMouseDoubleClick", QEvent::Type::GraphicsSceneMouseDoubleClick);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneContextMenu", QEvent::Type::GraphicsSceneContextMenu);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneHoverEnter", QEvent::Type::GraphicsSceneHoverEnter);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneHoverMove", QEvent::Type::GraphicsSceneHoverMove);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneHoverLeave", QEvent::Type::GraphicsSceneHoverLeave);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneHelp", QEvent::Type::GraphicsSceneHelp);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneDragEnter", QEvent::Type::GraphicsSceneDragEnter);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneDragMove", QEvent::Type::GraphicsSceneDragMove);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneDragLeave", QEvent::Type::GraphicsSceneDragLeave);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneDrop", QEvent::Type::GraphicsSceneDrop);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneWheel", QEvent::Type::GraphicsSceneWheel);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneLeave", QEvent::Type::GraphicsSceneLeave);
+        define_qenum_value_under(rb_cQEventType, "KeyboardLayoutChange", QEvent::Type::KeyboardLayoutChange);
+        define_qenum_value_under(rb_cQEventType, "DynamicPropertyChange", QEvent::Type::DynamicPropertyChange);
+        define_qenum_value_under(rb_cQEventType, "TabletEnterProximity", QEvent::Type::TabletEnterProximity);
+        define_qenum_value_under(rb_cQEventType, "TabletLeaveProximity", QEvent::Type::TabletLeaveProximity);
+        define_qenum_value_under(rb_cQEventType, "NonClientAreaMouseMove", QEvent::Type::NonClientAreaMouseMove);
+        define_qenum_value_under(rb_cQEventType, "NonClientAreaMouseButtonPress", QEvent::Type::NonClientAreaMouseButtonPress);
+        define_qenum_value_under(rb_cQEventType, "NonClientAreaMouseButtonRelease", QEvent::Type::NonClientAreaMouseButtonRelease);
+        define_qenum_value_under(rb_cQEventType, "NonClientAreaMouseButtonDblClick", QEvent::Type::NonClientAreaMouseButtonDblClick);
+        define_qenum_value_under(rb_cQEventType, "MacSizeChange", QEvent::Type::MacSizeChange);
+        define_qenum_value_under(rb_cQEventType, "ContentsRectChange", QEvent::Type::ContentsRectChange);
+        define_qenum_value_under(rb_cQEventType, "MacGLWindowChange", QEvent::Type::MacGLWindowChange);
+        define_qenum_value_under(rb_cQEventType, "FutureCallOut", QEvent::Type::FutureCallOut);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneResize", QEvent::Type::GraphicsSceneResize);
+        define_qenum_value_under(rb_cQEventType, "GraphicsSceneMove", QEvent::Type::GraphicsSceneMove);
+        define_qenum_value_under(rb_cQEventType, "CursorChange", QEvent::Type::CursorChange);
+        define_qenum_value_under(rb_cQEventType, "ToolTipChange", QEvent::Type::ToolTipChange);
+        define_qenum_value_under(rb_cQEventType, "NetworkReplyUpdated", QEvent::Type::NetworkReplyUpdated);
+        define_qenum_value_under(rb_cQEventType, "GrabMouse", QEvent::Type::GrabMouse);
+        define_qenum_value_under(rb_cQEventType, "UngrabMouse", QEvent::Type::UngrabMouse);
+        define_qenum_value_under(rb_cQEventType, "GrabKeyboard", QEvent::Type::GrabKeyboard);
+        define_qenum_value_under(rb_cQEventType, "UngrabKeyboard", QEvent::Type::UngrabKeyboard);
+        define_qenum_value_under(rb_cQEventType, "StateMachineSignal", QEvent::Type::StateMachineSignal);
+        define_qenum_value_under(rb_cQEventType, "StateMachineWrapped", QEvent::Type::StateMachineWrapped);
+        define_qenum_value_under(rb_cQEventType, "TouchBegin", QEvent::Type::TouchBegin);
+        define_qenum_value_under(rb_cQEventType, "TouchUpdate", QEvent::Type::TouchUpdate);
+        define_qenum_value_under(rb_cQEventType, "TouchEnd", QEvent::Type::TouchEnd);
+        define_qenum_value_under(rb_cQEventType, "NativeGesture", QEvent::Type::NativeGesture);
+        define_qenum_value_under(rb_cQEventType, "RequestSoftwareInputPanel", QEvent::Type::RequestSoftwareInputPanel);
+        define_qenum_value_under(rb_cQEventType, "CloseSoftwareInputPanel", QEvent::Type::CloseSoftwareInputPanel);
+        define_qenum_value_under(rb_cQEventType, "WinIdChange", QEvent::Type::WinIdChange);
+        define_qenum_value_under(rb_cQEventType, "Gesture", QEvent::Type::Gesture);
+        define_qenum_value_under(rb_cQEventType, "GestureOverride", QEvent::Type::GestureOverride);
+        define_qenum_value_under(rb_cQEventType, "ScrollPrepare", QEvent::Type::ScrollPrepare);
+        define_qenum_value_under(rb_cQEventType, "Scroll", QEvent::Type::Scroll);
+        define_qenum_value_under(rb_cQEventType, "Expose", QEvent::Type::Expose);
+        define_qenum_value_under(rb_cQEventType, "InputMethodQuery", QEvent::Type::InputMethodQuery);
+        define_qenum_value_under(rb_cQEventType, "OrientationChange", QEvent::Type::OrientationChange);
+        define_qenum_value_under(rb_cQEventType, "TouchCancel", QEvent::Type::TouchCancel);
+        define_qenum_value_under(rb_cQEventType, "ThemeChange", QEvent::Type::ThemeChange);
+        define_qenum_value_under(rb_cQEventType, "SockClose", QEvent::Type::SockClose);
+        define_qenum_value_under(rb_cQEventType, "PlatformPanel", QEvent::Type::PlatformPanel);
+        define_qenum_value_under(rb_cQEventType, "StyleAnimationUpdate", QEvent::Type::StyleAnimationUpdate);
+        define_qenum_value_under(rb_cQEventType, "ApplicationStateChange", QEvent::Type::ApplicationStateChange);
+        define_qenum_value_under(rb_cQEventType, "WindowChangeInternal", QEvent::Type::WindowChangeInternal);
+        define_qenum_value_under(rb_cQEventType, "ScreenChangeInternal", QEvent::Type::ScreenChangeInternal);
+        define_qenum_value_under(rb_cQEventType, "PlatformSurface", QEvent::Type::PlatformSurface);
+        define_qenum_value_under(rb_cQEventType, "Pointer", QEvent::Type::Pointer);
+        define_qenum_value_under(rb_cQEventType, "TabletTrackingChange", QEvent::Type::TabletTrackingChange);
+        define_qenum_value_under(rb_cQEventType, "WindowAboutToChangeInternal", QEvent::Type::WindowAboutToChangeInternal);
+        define_qenum_value_under(rb_cQEventType, "DevicePixelRatioChange", QEvent::Type::DevicePixelRatioChange);
+        define_qenum_value_under(rb_cQEventType, "ChildWindowAdded", QEvent::Type::ChildWindowAdded);
+        define_qenum_value_under(rb_cQEventType, "ChildWindowRemoved", QEvent::Type::ChildWindowRemoved);
+        define_qenum_value_under(rb_cQEventType, "ParentWindowAboutToChange", QEvent::Type::ParentWindowAboutToChange);
+        define_qenum_value_under(rb_cQEventType, "ParentWindowChange", QEvent::Type::ParentWindowChange);
+        define_qenum_value_under(rb_cQEventType, "SafeAreaMarginsChange", QEvent::Type::SafeAreaMarginsChange);
+        define_qenum_value_under(rb_cQEventType, "User", QEvent::Type::User);
+        define_qenum_value_under(rb_cQEventType, "MaxUser", QEvent::Type::MaxUser);
+
+    rb_cQChildEvent =
+        // RubyQt6::QtCore::QChildEvent
+        define_class_under<QChildEvent, QEvent>(rb_mQt6QtCore, "QChildEvent")
+            // Public Functions
+            .define_method("added", &QChildEvent::added)
+            .define_method("child", &QChildEvent::child)
+            .define_method("polished", &QChildEvent::polished)
+            .define_method("removed", &QChildEvent::removed);
+
+    rb_cQTimerEvent =
+        // RubyQt6::QtCore::QTimerEvent
+        define_class_under<QTimerEvent, QEvent>(rb_mQt6QtCore, "QTimerEvent")
+            // Public Functions
+            .define_method("id", &QTimerEvent::id)
+            .define_method("matches", &QTimerEvent::matches, Arg("timer"))
+            .define_method("timer_id", &QTimerEvent::timerId);
+
+    rb_cQDynamicPropertyChangeEvent =
+        // RubyQt6::QtCore::QDynamicPropertyChangeEvent
+        define_class_under<QDynamicPropertyChangeEvent, QEvent>(rb_mQt6QtCore, "QDynamicPropertyChangeEvent")
+            // Public Functions
+            .define_method("property_name", &QDynamicPropertyChangeEvent::propertyName);
+}

data/ext/qt6/qtcore/qcoreevent-rb.hpp

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

data/ext/qt6/qtcore/qdatetime-rb.cpp

@@ -0,0 +1,188 @@
+#include "qdatetime-rb.hpp"
+#include <qdatetime.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QTimeZone>
+
+using namespace Rice;
+
+Rice::Class rb_cQDateTime;
+Rice::Class rb_cQDate;
+Rice::Class rb_cQTime;
+
+int QDateTime_operator_compare(QDateTime *lhs, QDateTime *rhs)
+{
+    if (*lhs < *rhs) return -1;
+    if (*lhs > *rhs) return  1;
+    return 0;
+}
+
+int QDate_operator_compare(QDate *lhs, QDate *rhs)
+{
+    if (*lhs < *rhs) return -1;
+    if (*lhs > *rhs) return  1;
+    return 0;
+}
+
+int QTime_operator_compare(QTime *lhs, QTime *rhs)
+{
+    if (*lhs < *rhs) return -1;
+    if (*lhs > *rhs) return  1;
+    return 0;
+}
+
+void Init_qdatetime(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQDateTime =
+        // RubyQt6::QtCore::QDateTime
+        define_class_under<QDateTime>(rb_mQt6QtCore, "QDateTime")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_operator_compare", QDateTime_operator_compare, Arg("lhs"), Arg("rhs"))
+            // Constructor
+            .define_constructor(Constructor<QDateTime>())
+            .define_constructor(Constructor<QDateTime, QDate, QTime>(), Arg("date"), Arg("time"))
+            .define_constructor(Constructor<QDateTime, QDate, QTime, const QTimeZone &>(), Arg("date"), Arg("time"), Arg("time_zone"))
+            // Public Functions
+            .define_method("add_days", &QDateTime::addDays, Arg("days"))
+            .define_method("add_duration", &QDateTime::addDuration, Arg("msecs"))
+            .define_method("add_msecs", &QDateTime::addMSecs, Arg("msecs"))
+            .define_method("add_months", &QDateTime::addMonths, Arg("months"))
+            .define_method("add_secs", &QDateTime::addSecs, Arg("secs"))
+            .define_method("add_years", &QDateTime::addYears, Arg("years"))
+            .define_method("date", &QDateTime::date)
+            .define_method("days_to", &QDateTime::daysTo, Arg("other"))
+            .define_method("daylight_time?", &QDateTime::isDaylightTime)
+            .define_method("null?", &QDateTime::isNull)
+            .define_method("valid?", &QDateTime::isValid)
+            .define_method("msecs_to", &QDateTime::msecsTo, Arg("other"))
+            .define_method("offset_from_utc", &QDateTime::offsetFromUtc)
+            .define_method("secs_to", &QDateTime::secsTo, Arg("other"))
+            .define_method("set_date", &QDateTime::setDate, Arg("date"), Arg("resolve") = static_cast<QDateTime::TransitionResolution>(QDateTime::TransitionResolution::LegacyBehavior))
+            .define_method("set_msecs_since_epoch", &QDateTime::setMSecsSinceEpoch, Arg("msecs"))
+            .define_method("set_secs_since_epoch", &QDateTime::setSecsSinceEpoch, Arg("secs"))
+            .define_method("set_time", &QDateTime::setTime, Arg("time"), Arg("resolve") = static_cast<QDateTime::TransitionResolution>(QDateTime::TransitionResolution::LegacyBehavior))
+            .define_method("set_time_zone", &QDateTime::setTimeZone, Arg("to_zone"), Arg("resolve") = static_cast<QDateTime::TransitionResolution>(QDateTime::TransitionResolution::LegacyBehavior))
+            .define_method("time", &QDateTime::time)
+            .define_method("time_representation", &QDateTime::timeRepresentation)
+            .define_method("time_spec", &QDateTime::timeSpec)
+            .define_method("time_zone", &QDateTime::timeZone)
+            .define_method("time_zone_abbreviation", &QDateTime::timeZoneAbbreviation)
+            .define_method("to_local_time", &QDateTime::toLocalTime)
+            .define_method("to_msecs_since_epoch", &QDateTime::toMSecsSinceEpoch)
+            .define_method("to_offset_from_utc", &QDateTime::toOffsetFromUtc, Arg("offset_seconds"))
+            .define_method("to_secs_since_epoch", &QDateTime::toSecsSinceEpoch)
+            .define_method<QString (QDateTime::*)(Qt::DateFormat) const>("_to_string", &QDateTime::toString, Arg("format") = static_cast<Qt::DateFormat>(Qt::TextDate))
+            .define_method<QString (QDateTime::*)(const QString &) const>("_to_string", &QDateTime::toString, Arg("format"))
+            .define_method<QString (QDateTime::*)(const QString &, QCalendar) const>("_to_string", &QDateTime::toString, Arg("format"), Arg("cal"))
+            .define_method("to_time_zone", &QDateTime::toTimeZone, Arg("to_zone"))
+            .define_method("to_utc", &QDateTime::toUTC)
+            // Static Public Members
+            .define_singleton_function<QDateTime (*)()>("current_date_time", &QDateTime::currentDateTime)
+            .define_singleton_function<QDateTime (*)(const QTimeZone &)>("current_date_time", &QDateTime::currentDateTime, Arg("zone"))
+            .define_singleton_function("current_date_time_utc", &QDateTime::currentDateTimeUtc)
+            // .define_singleton_function("current_msecs_since_epoch", &QDateTime::currentMSecsSinceEpoch)
+            // .define_singleton_function("current_secs_since_epoch", &QDateTime::currentSecsSinceEpoch)
+            .define_singleton_function<QDateTime (*)(qint64)>("from_msecs_since_epoch", &QDateTime::fromMSecsSinceEpoch, Arg("msecs"))
+            .define_singleton_function<QDateTime (*)(qint64, const QTimeZone &)>("from_msecs_since_epoch", &QDateTime::fromMSecsSinceEpoch, Arg("msecs"), Arg("time_zone"))
+            .define_singleton_function<QDateTime (*)(qint64)>("from_secs_since_epoch", &QDateTime::fromSecsSinceEpoch, Arg("secs"))
+            .define_singleton_function<QDateTime (*)(qint64, const QTimeZone &)>("from_secs_since_epoch", &QDateTime::fromSecsSinceEpoch, Arg("secs"), Arg("time_zone"))
+            .define_singleton_function("from_std_time_point", &QDateTime::fromStdTimePoint, Arg("time"))
+            .define_singleton_function<QDateTime (*)(const QString &, Qt::DateFormat)>("from_string", &QDateTime::fromString, Arg("string"), Arg("format") = static_cast<Qt::DateFormat>(Qt::TextDate))
+            .define_singleton_function<QDateTime (*)(const QString &, const QString &, QCalendar)>("from_string", &QDateTime::fromString, Arg("string"), Arg("format"), Arg("cal"))
+            .define_singleton_function<QDateTime (*)(const QString &, const QString &, int)>("from_string", &QDateTime::fromString, Arg("string"), Arg("format"), Arg("base_year") = static_cast<int>(QLocale::DefaultTwoDigitBaseYear))
+            .define_singleton_function<QDateTime (*)(const QString &, const QString &, int, QCalendar)>("from_string", &QDateTime::fromString, Arg("string"), Arg("format"), Arg("base_year"), Arg("cal"));
+
+    Data_Type<QDateTime::TransitionResolution> rb_cQDateTimeTransitionResolution =
+        // RubyQt6::QtCore::QDateTime::TransitionResolution
+        define_qenum_under<QDateTime::TransitionResolution>(rb_cQDateTime, "TransitionResolution");
+        define_qenum_value_under(rb_cQDateTimeTransitionResolution, "Reject", QDateTime::TransitionResolution::Reject);
+        define_qenum_value_under(rb_cQDateTimeTransitionResolution, "RelativeToBefore", QDateTime::TransitionResolution::RelativeToBefore);
+        define_qenum_value_under(rb_cQDateTimeTransitionResolution, "RelativeToAfter", QDateTime::TransitionResolution::RelativeToAfter);
+        define_qenum_value_under(rb_cQDateTimeTransitionResolution, "PreferBefore", QDateTime::TransitionResolution::PreferBefore);
+        define_qenum_value_under(rb_cQDateTimeTransitionResolution, "PreferAfter", QDateTime::TransitionResolution::PreferAfter);
+        define_qenum_value_under(rb_cQDateTimeTransitionResolution, "PreferStandard", QDateTime::TransitionResolution::PreferStandard);
+        define_qenum_value_under(rb_cQDateTimeTransitionResolution, "PreferDaylightSaving", QDateTime::TransitionResolution::PreferDaylightSaving);
+        define_qenum_value_under(rb_cQDateTimeTransitionResolution, "LegacyBehavior", QDateTime::TransitionResolution::LegacyBehavior);
+
+    rb_cQDate =
+        // RubyQt6::QtCore::QDate
+        define_class_under<QDate>(rb_mQt6QtCore, "QDate")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_operator_compare", QDate_operator_compare, Arg("lhs"), Arg("rhs"))
+            // Constructor
+            .define_constructor(Constructor<QDate, int, int, int>(), Arg("y"), Arg("m"), Arg("d"))
+            // Public Functions
+            .define_method("add_days", &QDate::addDays, Arg("days"))
+            .define_method<QDate (QDate::*)(int) const>("add_months", &QDate::addMonths, Arg("months"))
+            .define_method<QDate (QDate::*)(int, QCalendar) const>("add_months", &QDate::addMonths, Arg("months"), Arg("cal"))
+            .define_method<QDate (QDate::*)(int) const>("add_years", &QDate::addYears, Arg("years"))
+            .define_method<QDate (QDate::*)(int, QCalendar) const>("add_years", &QDate::addYears, Arg("years"), Arg("cal"))
+            .define_method<int (QDate::*)() const>("day", &QDate::day)
+            .define_method<int (QDate::*)(QCalendar) const>("day", &QDate::day, Arg("cal"))
+            .define_method<int (QDate::*)() const>("day_of_week", &QDate::dayOfWeek)
+            .define_method<int (QDate::*)(QCalendar) const>("day_of_week", &QDate::dayOfWeek, Arg("cal"))
+            .define_method<int (QDate::*)() const>("day_of_year", &QDate::dayOfYear)
+            .define_method<int (QDate::*)(QCalendar) const>("day_of_year", &QDate::dayOfYear, Arg("cal"))
+            .define_method<int (QDate::*)() const>("days_in_month", &QDate::daysInMonth)
+            .define_method<int (QDate::*)(QCalendar) const>("days_in_month", &QDate::daysInMonth, Arg("cal"))
+            .define_method<int (QDate::*)() const>("days_in_year", &QDate::daysInYear)
+            .define_method<int (QDate::*)(QCalendar) const>("days_in_year", &QDate::daysInYear, Arg("cal"))
+            .define_method("days_to", &QDate::daysTo, Arg("d"))
+            .define_method<QDateTime (QDate::*)() const>("end_of_day", &QDate::endOfDay)
+            .define_method<QDateTime (QDate::*)(const QTimeZone &) const>("end_of_day", &QDate::endOfDay, Arg("zone"))
+            .define_method("get_date", &QDate::getDate, Arg("year"), Arg("month"), Arg("day"))
+            .define_method("null?", &QDate::isNull)
+            .define_method<bool (QDate::*)() const>("valid?", &QDate::isValid)
+            .define_method<int (QDate::*)() const>("month", &QDate::month)
+            .define_method<int (QDate::*)(QCalendar) const>("month", &QDate::month, Arg("cal"))
+            .define_method<bool (QDate::*)(int, int, int)>("set_date", &QDate::setDate, Arg("year"), Arg("month"), Arg("day"))
+            .define_method<bool (QDate::*)(int, int, int, QCalendar)>("set_date", &QDate::setDate, Arg("year"), Arg("month"), Arg("day"), Arg("cal"))
+            .define_method<QDateTime (QDate::*)() const>("start_of_day", &QDate::startOfDay)
+            .define_method<QDateTime (QDate::*)(const QTimeZone &) const>("start_of_day", &QDate::startOfDay, Arg("zone"))
+            .define_method("to_julian_day", &QDate::toJulianDay)
+            .define_method<QString (QDate::*)(Qt::DateFormat) const>("_to_string", &QDate::toString, Arg("format") = static_cast<Qt::DateFormat>(Qt::TextDate))
+            .define_method<QString (QDate::*)(const QString &) const>("_to_string", &QDate::toString, Arg("format"))
+            .define_method<QString (QDate::*)(const QString &, QCalendar) const>("_to_string", &QDate::toString, Arg("format"), Arg("cal"))
+            .define_method("week_number", &QDate::weekNumber, Arg("year_num") = static_cast<int *>(nullptr))
+            .define_method<int (QDate::*)() const>("year", &QDate::year)
+            .define_method<int (QDate::*)(QCalendar) const>("year", &QDate::year, Arg("cal"))
+            // Static Public Members
+            .define_singleton_function("current_date", &QDate::currentDate)
+            .define_singleton_function("from_julian_day", &QDate::fromJulianDay, Arg("jd_"))
+            .define_singleton_function<QDate (*)(const QString &, Qt::DateFormat)>("from_string", &QDate::fromString, Arg("string"), Arg("format") = static_cast<Qt::DateFormat>(Qt::TextDate))
+            .define_singleton_function<QDate (*)(const QString &, const QString &, QCalendar)>("from_string", &QDate::fromString, Arg("string"), Arg("format"), Arg("cal"))
+            .define_singleton_function<QDate (*)(const QString &, const QString &, int)>("from_string", &QDate::fromString, Arg("string"), Arg("format"), Arg("base_year") = static_cast<int>(QLocale::DefaultTwoDigitBaseYear))
+            .define_singleton_function<QDate (*)(const QString &, const QString &, int, QCalendar)>("from_string", &QDate::fromString, Arg("string"), Arg("format"), Arg("base_year"), Arg("cal"))
+            .define_singleton_function("leap_year?", &QDate::isLeapYear, Arg("year"))
+            .define_singleton_function<bool (*)(int, int, int)>("valid?", &QDate::isValid, Arg("y"), Arg("m"), Arg("d"));
+
+    rb_cQTime =
+        // RubyQt6::QtCore::QTime
+        define_class_under<QTime>(rb_mQt6QtCore, "QTime")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_operator_compare", QTime_operator_compare, Arg("lhs"), Arg("rhs"))
+            // Constructor
+            .define_constructor(Constructor<QTime, int, int>(), Arg("h"), Arg("m"))
+            .define_constructor(Constructor<QTime, int, int, int>(), Arg("h"), Arg("m"), Arg("s"))
+            // Public Functions
+            .define_method("add_msecs", &QTime::addMSecs, Arg("ms"))
+            .define_method("add_secs", &QTime::addSecs, Arg("secs"))
+            .define_method("hour", &QTime::hour)
+            .define_method("null?", &QTime::isNull)
+            .define_method<bool (QTime::*)() const>("valid?", &QTime::isValid)
+            .define_method("minute", &QTime::minute)
+            .define_method("msec", &QTime::msec)
+            .define_method("msecs_since_start_of_day", &QTime::msecsSinceStartOfDay)
+            .define_method("msecs_to", &QTime::msecsTo, Arg("t"))
+            .define_method("second", &QTime::second)
+            .define_method("secs_to", &QTime::secsTo, Arg("t"))
+            .define_method("set_hms", &QTime::setHMS, Arg("h"), Arg("m"), Arg("s"), Arg("ms") = static_cast<int>(0))
+            .define_method<QString (QTime::*)(Qt::DateFormat) const>("_to_string", &QTime::toString, Arg("f") = static_cast<Qt::DateFormat>(Qt::TextDate))
+            .define_method<QString (QTime::*)(const QString &) const>("_to_string", &QTime::toString, Arg("format"))
+            // Static Public Members
+            .define_singleton_function("current_time", &QTime::currentTime)
+            .define_singleton_function("from_msecs_since_start_of_day", &QTime::fromMSecsSinceStartOfDay, Arg("msecs"))
+            .define_singleton_function<QTime (*)(const QString &, Qt::DateFormat)>("from_string", &QTime::fromString, Arg("string"), Arg("format") = static_cast<Qt::DateFormat>(Qt::TextDate))
+            .define_singleton_function<QTime (*)(const QString &, const QString &)>("from_string", &QTime::fromString, Arg("string"), Arg("format"))
+            .define_singleton_function<bool (*)(int, int, int, int)>("valid?", &QTime::isValid, Arg("h"), Arg("m"), Arg("s"), Arg("ms") = static_cast<int>(0));
+}

data/ext/qt6/qtcore/qdatetime-rb.hpp

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

data/ext/qt6/qtcore/qdir-rb.cpp

@@ -0,0 +1,133 @@
+#include "qdir-rb.hpp"
+#include <qdir.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQDir;
+
+void Init_qdir(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQDir =
+        // RubyQt6::QtCore::QDir
+        define_class_under<QDir>(rb_mQt6QtCore, "QDir")
+            // RubyQt6-Defined Functions
+            .define_method("mkdir", [](QDir *self, const QString &dir_name) -> bool { return self->mkdir(dir_name); }, Arg("dir_name"))
+            .define_method("mkdir", [](QDir *self, const QString &dir_name, QFileDevice::Permissions permissions) -> bool { return self->mkdir(dir_name, permissions); }, Arg("dir_name"), Arg("permissions"))
+            // Constructor
+            .define_constructor(Constructor<QDir, const QString &>(), Arg("path"))
+            .define_constructor(Constructor<QDir, const QString &, const QString &>(), Arg("path"), Arg("name_filter"))
+            // Public Functions
+            .define_method("absolute_file_path", &QDir::absoluteFilePath, Arg("file_name"))
+            .define_method("absolute_path", &QDir::absolutePath)
+            .define_method("canonical_path", &QDir::canonicalPath)
+            .define_method("cd", &QDir::cd, Arg("dir_name"))
+            .define_method("cd_up", &QDir::cdUp)
+            .define_method("count", &QDir::count, Arg("_"))
+            .define_method("dir_name", &QDir::dirName)
+            .define_method<QFileInfoList (QDir::*)(QDir::Filters, QDir::SortFlags) const>("entry_info_list", &QDir::entryInfoList, Arg("filters") = static_cast<QDir::Filters>(QDir::Filter::NoFilter), Arg("sort") = static_cast<QDir::SortFlags>(QDir::SortFlag::NoSort))
+            .define_method<QFileInfoList (QDir::*)(const QStringList &, QDir::Filters, QDir::SortFlags) const>("entry_info_list", &QDir::entryInfoList, Arg("name_filters"), Arg("filters") = static_cast<QDir::Filters>(QDir::Filter::NoFilter), Arg("sort") = static_cast<QDir::SortFlags>(QDir::SortFlag::NoSort))
+            .define_method<QStringList (QDir::*)(QDir::Filters, QDir::SortFlags) const>("entry_list", &QDir::entryList, Arg("filters") = static_cast<QDir::Filters>(QDir::Filter::NoFilter), Arg("sort") = static_cast<QDir::SortFlags>(QDir::SortFlag::NoSort))
+            .define_method<QStringList (QDir::*)(const QStringList &, QDir::Filters, QDir::SortFlags) const>("entry_list", &QDir::entryList, Arg("name_filters"), Arg("filters") = static_cast<QDir::Filters>(QDir::Filter::NoFilter), Arg("sort") = static_cast<QDir::SortFlags>(QDir::SortFlag::NoSort))
+            .define_method<bool (QDir::*)() const>("exists", &QDir::exists)
+            .define_method<bool (QDir::*)(const QString &) const>("exists", &QDir::exists, Arg("name"))
+            .define_method("file_path", &QDir::filePath, Arg("file_name"))
+            .define_method("filesystem_absolute_path", &QDir::filesystemAbsolutePath)
+            .define_method("filesystem_canonical_path", &QDir::filesystemCanonicalPath)
+            .define_method("filesystem_path", &QDir::filesystemPath)
+            .define_method("filter", &QDir::filter)
+            .define_method("absolute?", &QDir::isAbsolute)
+            .define_method("empty?", &QDir::isEmpty, Arg("filters") = static_cast<QDir::Filters>(QDir::Filters(QDir::Filter::AllEntries | QDir::Filter::NoDotAndDotDot)))
+            .define_method("readable?", &QDir::isReadable)
+            .define_method("relative?", &QDir::isRelative)
+            .define_method("root?", &QDir::isRoot)
+            .define_method("make_absolute", &QDir::makeAbsolute)
+            .define_method("mkpath", &QDir::mkpath, Arg("dir_path"))
+            .define_method("name_filters", &QDir::nameFilters)
+            .define_method("path", &QDir::path)
+            .define_method("refresh", &QDir::refresh)
+            .define_method("relative_file_path", &QDir::relativeFilePath, Arg("file_name"))
+            .define_method("remove", &QDir::remove, Arg("file_name"))
+            .define_method("remove_recursively", &QDir::removeRecursively)
+            .define_method("rename", &QDir::rename, Arg("old_name"), Arg("new_name"))
+            .define_method("rmdir", &QDir::rmdir, Arg("dir_name"))
+            .define_method("rmpath", &QDir::rmpath, Arg("dir_path"))
+            .define_method("set_filter", &QDir::setFilter, Arg("filter"))
+            .define_method("set_name_filters", &QDir::setNameFilters, Arg("name_filters"))
+            .define_method<void (QDir::*)(const QString &path)>("set_path", &QDir::setPath, Arg("path"))
+            .define_method("set_sorting", &QDir::setSorting, Arg("sort"))
+            .define_method("sorting", &QDir::sorting)
+            // Static Public Members
+            .define_singleton_function<void (*)(const QString &, const QString &)>("add_search_path", &QDir::addSearchPath, Arg("prefix"), Arg("path"))
+            .define_singleton_function("clean_path", &QDir::cleanPath, Arg("path"))
+            .define_singleton_function("current", &QDir::current)
+            .define_singleton_function("current_path", &QDir::currentPath)
+            .define_singleton_function("drives", &QDir::drives)
+            .define_singleton_function("from_native_separators", &QDir::fromNativeSeparators, Arg("path_name"))
+            .define_singleton_function("home", &QDir::home)
+            .define_singleton_function("home_path", &QDir::homePath)
+            .define_singleton_function("absolute_path?", &QDir::isAbsolutePath, Arg("path"))
+            .define_singleton_function("relative_path?", &QDir::isRelativePath, Arg("path"))
+            // .define_singleton_function("list_separator", &QDir::listSeparator)
+            .define_singleton_function<bool (*)(const QString &, const QString &)>("match", &QDir::match, Arg("filter"), Arg("file_name"))
+            .define_singleton_function<bool (*)(const QStringList &, const QString &)>("match", &QDir::match, Arg("filters"), Arg("file_name"))
+            .define_singleton_function("name_filters_from_string", &QDir::nameFiltersFromString, Arg("name_filter"))
+            .define_singleton_function("root", &QDir::root)
+            .define_singleton_function("root_path", &QDir::rootPath)
+            .define_singleton_function("search_paths", &QDir::searchPaths, Arg("prefix"))
+            .define_singleton_function("separator", &QDir::separator)
+            .define_singleton_function("set_current", &QDir::setCurrent, Arg("path"))
+            .define_singleton_function("set_search_paths", &QDir::setSearchPaths, Arg("prefix"), Arg("search_paths"))
+            .define_singleton_function("temp", &QDir::temp)
+            .define_singleton_function("temp_path", &QDir::tempPath)
+            .define_singleton_function("to_native_separators", &QDir::toNativeSeparators, Arg("path_name"));
+
+    Data_Type<QDir::Filter> rb_cQDirFilter =
+        // RubyQt6::QtCore::QDir::Filter
+        define_qenum_under<QDir::Filter>(rb_cQDir, "Filter");
+        define_qenum_value_under(rb_cQDirFilter, "Dirs", QDir::Filter::Dirs);
+        define_qenum_value_under(rb_cQDirFilter, "Files", QDir::Filter::Files);
+        define_qenum_value_under(rb_cQDirFilter, "Drives", QDir::Filter::Drives);
+        define_qenum_value_under(rb_cQDirFilter, "NoSymLinks", QDir::Filter::NoSymLinks);
+        define_qenum_value_under(rb_cQDirFilter, "AllEntries", QDir::Filter::AllEntries);
+        define_qenum_value_under(rb_cQDirFilter, "TypeMask", QDir::Filter::TypeMask);
+        define_qenum_value_under(rb_cQDirFilter, "Readable", QDir::Filter::Readable);
+        define_qenum_value_under(rb_cQDirFilter, "Writable", QDir::Filter::Writable);
+        define_qenum_value_under(rb_cQDirFilter, "Executable", QDir::Filter::Executable);
+        define_qenum_value_under(rb_cQDirFilter, "PermissionMask", QDir::Filter::PermissionMask);
+        define_qenum_value_under(rb_cQDirFilter, "Modified", QDir::Filter::Modified);
+        define_qenum_value_under(rb_cQDirFilter, "Hidden", QDir::Filter::Hidden);
+        define_qenum_value_under(rb_cQDirFilter, "System", QDir::Filter::System);
+        define_qenum_value_under(rb_cQDirFilter, "AccessMask", QDir::Filter::AccessMask);
+        define_qenum_value_under(rb_cQDirFilter, "AllDirs", QDir::Filter::AllDirs);
+        define_qenum_value_under(rb_cQDirFilter, "CaseSensitive", QDir::Filter::CaseSensitive);
+        define_qenum_value_under(rb_cQDirFilter, "NoDot", QDir::Filter::NoDot);
+        define_qenum_value_under(rb_cQDirFilter, "NoDotDot", QDir::Filter::NoDotDot);
+        define_qenum_value_under(rb_cQDirFilter, "NoDotAndDotDot", QDir::Filter::NoDotAndDotDot);
+        define_qenum_value_under(rb_cQDirFilter, "NoFilter", QDir::Filter::NoFilter);
+
+    Data_Type<QDir::SortFlag> rb_cQDirSortFlag =
+        // RubyQt6::QtCore::QDir::SortFlag
+        define_qenum_under<QDir::SortFlag>(rb_cQDir, "SortFlag");
+        define_qenum_value_under(rb_cQDirSortFlag, "Name", QDir::SortFlag::Name);
+        define_qenum_value_under(rb_cQDirSortFlag, "Time", QDir::SortFlag::Time);
+        define_qenum_value_under(rb_cQDirSortFlag, "Size", QDir::SortFlag::Size);
+        define_qenum_value_under(rb_cQDirSortFlag, "Unsorted", QDir::SortFlag::Unsorted);
+        define_qenum_value_under(rb_cQDirSortFlag, "SortByMask", QDir::SortFlag::SortByMask);
+        define_qenum_value_under(rb_cQDirSortFlag, "DirsFirst", QDir::SortFlag::DirsFirst);
+        define_qenum_value_under(rb_cQDirSortFlag, "Reversed", QDir::SortFlag::Reversed);
+        define_qenum_value_under(rb_cQDirSortFlag, "IgnoreCase", QDir::SortFlag::IgnoreCase);
+        define_qenum_value_under(rb_cQDirSortFlag, "DirsLast", QDir::SortFlag::DirsLast);
+        define_qenum_value_under(rb_cQDirSortFlag, "LocaleAware", QDir::SortFlag::LocaleAware);
+        define_qenum_value_under(rb_cQDirSortFlag, "Type", QDir::SortFlag::Type);
+        define_qenum_value_under(rb_cQDirSortFlag, "NoSort", QDir::SortFlag::NoSort);
+
+    Data_Type<QFlags<QDir::Filter>> rb_cQDirFilters =
+        // RubyQt6::QtCore::QDir::Filters
+        define_qflags_under<QDir::Filter>(rb_cQDir, "Filters");
+
+    Data_Type<QFlags<QDir::SortFlag>> rb_cQDirSortFlags =
+        // RubyQt6::QtCore::QDir::SortFlags
+        define_qflags_under<QDir::SortFlag>(rb_cQDir, "SortFlags");
+}

data/ext/qt6/qtcore/qdir-rb.hpp

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