ruby-qt6-rice 1.0.0

data/include/bando/qwidget.hpp

@@ -0,0 +1,187 @@
+// This file is part of [RubyQt6](https://github.com/souk4711/ruby-qt6).
+//
+// It is licensed under the LGPLv3, included below.
+//
+// As a special exception to the GNU Lesser General Public License version 3
+// ("LGPL3"), the copyright holders of this Library give you permission to
+// convey to a third party a Combined Work that links statically or dynamically
+// to this Library without providing any Minimal Corresponding Source or
+// Minimal Application Code as set out in 4d or providing the installation
+// information set out in section 4e, provided that you comply with the other
+// provisions of LGPL3 and provided that you meet, for the Application the
+// terms and conditions of the license(s) which apply to the Application.
+//
+// Except as stated in this special exception, the provisions of LGPL3 will
+// continue to comply in full to this Library. If you modify this Library, you
+// may apply this exception to your version of this Library, but you are not
+// obliged to do so. If you do not wish to do so, delete this exception
+// statement from your version. This exception does not (and cannot) modify any
+// license terms which apply to the Application, with which you must still
+// comply.
+
+#ifndef BANDO_QWIDGET_HPP
+#define BANDO_QWIDGET_HPP
+
+#include <bando/common.hpp>
+#include <QActionEvent>
+#include <QEvent>
+#include <QChildEvent>
+#include <QCloseEvent>
+#include <QContextMenuEvent>
+#include <QDragEnterEvent>
+#include <QDragLeaveEvent>
+#include <QDragMoveEvent>
+#include <QDropEvent>
+#include <QEnterEvent>
+#include <QFocusEvent>
+#include <QFocusEvent>
+#include <QHideEvent>
+#include <QInputMethodEvent>
+#include <QKeyEvent>
+#include <QKeyEvent>
+#include <QEvent>
+#include <QMouseEvent>
+#include <QMouseEvent>
+#include <QMouseEvent>
+#include <QMouseEvent>
+#include <QMoveEvent>
+#include <QPaintEvent>
+#include <QResizeEvent>
+#include <QShowEvent>
+#include <QTabletEvent>
+#include <QTimerEvent>
+#include <QWheelEvent>
+
+template <typename Class_T, typename... Arg_Ts> class BandoQWidget : public Class_T
+{
+  public:
+    BandoQWidget(Arg_Ts... args) : Class_T(args...), value_(Qnil), value_address_(nullptr), mo_(nullptr) {};
+    BandoQWidget(const BandoQWidget &) = delete;
+    BandoQWidget &operator=(const BandoQWidget &) = delete;
+    BandoQWidget(BandoQWidget &&) = delete;
+    BandoQWidget &operator=(BandoQWidget &&) = delete;
+    ~BandoQWidget() override { bando_finalizer<BandoQWidget>(this); };
+
+    void initializeValue(Rice::Object value, QMetaObject *mo) { bando_initializeValue<BandoQWidget>(this, value, mo); };
+    Rice::Object value() { return this->value_; };
+
+    const QMetaObject *metaObject() const override { return bando_metaObject<BandoQWidget, Class_T>(this); };
+    int qt_metacall(QMetaObject::Call call, int id, void **args) override { return bando_qt_metacall<BandoQWidget>(this, call, id, args); };
+
+    bool event(QEvent *event) override { return bando_handleQObjectEvent<BandoQWidget>(this, event); };
+    bool eventFilter(QObject *watched, QEvent *event) override { return bando_handleQObjectEventFilter<BandoQWidget>(this, watched, event); };
+
+    void childEvent(QChildEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::childEvent); };
+    void timerEvent(QTimerEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::timerEvent); };
+    QObject *sender() const { return this->Class_T::sender(); }
+
+    void actionEvent(QActionEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::actionEvent); };
+    void changeEvent(QEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::changeEvent); };
+    void closeEvent(QCloseEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::closeEvent); };
+    void contextMenuEvent(QContextMenuEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::contextMenuEvent); };
+    void dragEnterEvent(QDragEnterEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::dragEnterEvent); };
+    void dragLeaveEvent(QDragLeaveEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::dragLeaveEvent); };
+    void dragMoveEvent(QDragMoveEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::dragMoveEvent); };
+    void dropEvent(QDropEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::dropEvent); };
+    void enterEvent(QEnterEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::enterEvent); };
+    void focusInEvent(QFocusEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::focusInEvent); };
+    void focusOutEvent(QFocusEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::focusOutEvent); };
+    void hideEvent(QHideEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::hideEvent); };
+    void inputMethodEvent(QInputMethodEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::inputMethodEvent); };
+    void keyPressEvent(QKeyEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::keyPressEvent); };
+    void keyReleaseEvent(QKeyEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::keyReleaseEvent); };
+    void leaveEvent(QEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::leaveEvent); };
+    void mouseDoubleClickEvent(QMouseEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::mouseDoubleClickEvent); };
+    void mouseMoveEvent(QMouseEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::mouseMoveEvent); };
+    void mousePressEvent(QMouseEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::mousePressEvent); };
+    void mouseReleaseEvent(QMouseEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::mouseReleaseEvent); };
+    void moveEvent(QMoveEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::moveEvent); };
+    void paintEvent(QPaintEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::paintEvent); };
+    void resizeEvent(QResizeEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::resizeEvent); };
+    void showEvent(QShowEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::showEvent); };
+    void tabletEvent(QTabletEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::tabletEvent); };
+    void wheelEvent(QWheelEvent *event) override { bando_handleEvent<BandoQWidget>(this, event, bando_FunctionName::wheelEvent); };
+
+    QSize minimumSizeHint() const override {
+        Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
+        auto rb_name = Rice::Identifier("minimum_size_hint");
+        auto rb_return = this->value_.call(rb_name);
+        return Rice::detail::From_Ruby<QSize>().convert(rb_return);
+    };
+
+    QSize sizeHint() const override {
+        Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
+        auto rb_name = Rice::Identifier("size_hint");
+        auto rb_return = this->value_.call(rb_name);
+        return Rice::detail::From_Ruby<QSize>().convert(rb_return);
+    };
+
+  public:
+    bool Class_T_handleQObjectEvent(QEvent *event) { return this->Class_T::event(event); };
+    bool Class_T_handleQObjectEventFilter(QObject *watched, QEvent *event) { return this->Class_T::eventFilter(watched, event); };
+
+    void Class_T_handleEvent(bando_FunctionName name, QEvent *event) {
+        switch (name)
+        {
+        case bando_FunctionName::childEvent: return this->Class_T::childEvent(static_cast<QChildEvent *>(event));
+        case bando_FunctionName::timerEvent: return this->Class_T::timerEvent(static_cast<QTimerEvent *>(event));
+
+        case bando_FunctionName::actionEvent: return this->Class_T::actionEvent(static_cast<QActionEvent *>(event));
+        case bando_FunctionName::changeEvent: return this->Class_T::changeEvent(event);
+        case bando_FunctionName::closeEvent: return this->Class_T::closeEvent(static_cast<QCloseEvent *>(event));
+        case bando_FunctionName::contextMenuEvent: return this->Class_T::contextMenuEvent(static_cast<QContextMenuEvent *>(event));
+        case bando_FunctionName::dragEnterEvent: return this->Class_T::dragEnterEvent(static_cast<QDragEnterEvent *>(event));
+        case bando_FunctionName::dragLeaveEvent: return this->Class_T::dragLeaveEvent(static_cast<QDragLeaveEvent *>(event));
+        case bando_FunctionName::dragMoveEvent: return this->Class_T::dragMoveEvent(static_cast<QDragMoveEvent *>(event));
+        case bando_FunctionName::dropEvent: return this->Class_T::dropEvent(static_cast<QDropEvent *>(event));
+        case bando_FunctionName::enterEvent: return this->Class_T::enterEvent(static_cast<QEnterEvent *>(event));
+        case bando_FunctionName::focusInEvent: return this->Class_T::focusInEvent(static_cast<QFocusEvent *>(event));
+        case bando_FunctionName::focusOutEvent: return this->Class_T::focusOutEvent(static_cast<QFocusEvent *>(event));
+        case bando_FunctionName::hideEvent: return this->Class_T::hideEvent(static_cast<QHideEvent *>(event));
+        case bando_FunctionName::inputMethodEvent: return this->Class_T::inputMethodEvent(static_cast<QInputMethodEvent *>(event));
+        case bando_FunctionName::keyPressEvent: return this->Class_T::keyPressEvent(static_cast<QKeyEvent *>(event));
+        case bando_FunctionName::keyReleaseEvent: return this->Class_T::keyReleaseEvent(static_cast<QKeyEvent *>(event));
+        case bando_FunctionName::leaveEvent: return this->Class_T::leaveEvent(event);
+        case bando_FunctionName::mouseDoubleClickEvent: return this->Class_T::mouseDoubleClickEvent(static_cast<QMouseEvent *>(event));
+        case bando_FunctionName::mouseMoveEvent: return this->Class_T::mouseMoveEvent(static_cast<QMouseEvent *>(event));
+        case bando_FunctionName::mousePressEvent: return this->Class_T::mousePressEvent(static_cast<QMouseEvent *>(event));
+        case bando_FunctionName::mouseReleaseEvent: return this->Class_T::mouseReleaseEvent(static_cast<QMouseEvent *>(event));
+        case bando_FunctionName::moveEvent: return this->Class_T::moveEvent(static_cast<QMoveEvent *>(event));
+        case bando_FunctionName::paintEvent: return this->Class_T::paintEvent(static_cast<QPaintEvent *>(event));
+        case bando_FunctionName::resizeEvent: return this->Class_T::resizeEvent(static_cast<QResizeEvent *>(event));
+        case bando_FunctionName::showEvent: return this->Class_T::showEvent(static_cast<QShowEvent *>(event));
+        case bando_FunctionName::tabletEvent: return this->Class_T::tabletEvent(static_cast<QTabletEvent *>(event));
+        case bando_FunctionName::wheelEvent: return this->Class_T::wheelEvent(static_cast<QWheelEvent *>(event));
+        default: Q_UNREACHABLE(); break;
+        }
+    };
+
+  public:
+    template <typename BC_T, typename C_T> friend const QMetaObject *bando_metaObject(const BC_T *self);
+
+    Rice::Object value_;
+    VALUE *value_address_;
+
+    QMetaObject *mo_;
+};
+
+template <typename BC_T, typename C_T>
+Rice::Data_Type<BC_T> define_bando_qwidget_under(Rice::Module module, char const *name)
+{
+    Rice::Data_Type<BC_T> bando_qlass =
+        Rice::define_class_under<BC_T, C_T>(module, name)
+            .define_method("_initialize_ruby_value", &BC_T::initializeValue, Rice::Arg("value"), Rice::Arg("mo"))
+            .define_method("_ruby_value", &BC_T::value)
+            .define_method("_ruby_value_handle_event", &BC_T::Class_T_handleEvent, Rice::Arg("name"), Rice::Arg("event"))
+            .define_method("_event", &BC_T::Class_T_handleQObjectEvent, Rice::Arg("event"))
+            .define_method("_event_filter", &BC_T::Class_T_handleQObjectEventFilter, Rice::Arg("watched"), Rice::Arg("event"))
+            .define_method("sender", &BC_T::sender);
+
+    bando_qlass
+        .define_method("minimum_size_hint", [](BC_T *self) -> QSize { return self->C_T::minimumSizeHint(); })
+        .define_method("size_hint", [](BC_T *self) -> QSize { return self->C_T::sizeHint(); });
+
+    return bando_qlass;
+}
+
+#endif

data/include/rice/qt6/qdbusreply.hpp

@@ -0,0 +1,53 @@
+// This file is part of [RubyQt6](https://github.com/souk4711/ruby-qt6).
+//
+// It is licensed under the LGPLv3, included below.
+//
+// As a special exception to the GNU Lesser General Public License version 3
+// ("LGPL3"), the copyright holders of this Library give you permission to
+// convey to a third party a Combined Work that links statically or dynamically
+// to this Library without providing any Minimal Corresponding Source or
+// Minimal Application Code as set out in 4d or providing the installation
+// information set out in section 4e, provided that you comply with the other
+// provisions of LGPL3 and provided that you meet, for the Application the
+// terms and conditions of the license(s) which apply to the Application.
+//
+// Except as stated in this special exception, the provisions of LGPL3 will
+// continue to comply in full to this Library. If you modify this Library, you
+// may apply this exception to your version of this Library, but you are not
+// obliged to do so. If you do not wish to do so, delete this exception
+// statement from your version. This exception does not (and cannot) modify any
+// license terms which apply to the Application, with which you must still
+// comply.
+
+#ifndef RICE_QDBUSREPLY_HPP
+#define RICE_QDBUSREPLY_HPP
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <QDBusReply>
+
+using namespace Rice;
+
+template <typename Value_T>
+void define_qdbusreply_under(Module module)
+{
+    using QDBusReply_T = QDBusReply<Value_T>;
+    using QDBusPendingReply_T = QDBusPendingReply<Value_T>;
+
+    detail::TypeMapper<QDBusReply_T> typeMapper;
+    std::string klassName = typeMapper.rubyName();
+    Identifier id(klassName);
+
+    define_class_under<QDBusReply_T>(module, id)
+        .define_constructor(Constructor<QDBusReply_T, const QDBusError &>(), Arg("dbus_error") = static_cast<const QDBusError &>(QDBusError()))
+        .define_constructor(Constructor<QDBusReply_T, const QDBusMessage &>(), Arg("reply"))
+        .define_constructor(Constructor<QDBusReply_T, const QDBusPendingCall &>(), Arg("pcall"))
+        .define_constructor(Constructor<QDBusReply_T, const QDBusPendingReply_T &>(), Arg("reply"))
+        .define_constructor(Constructor<QDBusReply_T, const QDBusReply_T &>(), Arg("other"))
+        .template define_method<const QDBusError &(QDBusReply_T::*)()>("error", &QDBusReply_T::error)
+        .template define_method("valid?", &QDBusReply_T::isValid)
+        .template define_method("value", &QDBusReply_T::value);
+};
+
+#endif

data/include/rice/qt6/qenum.hpp

@@ -0,0 +1,51 @@
+// This file is part of [RubyQt6](https://github.com/souk4711/ruby-qt6).
+//
+// It is licensed under the LGPLv3, included below.
+//
+// As a special exception to the GNU Lesser General Public License version 3
+// ("LGPL3"), the copyright holders of this Library give you permission to
+// convey to a third party a Combined Work that links statically or dynamically
+// to this Library without providing any Minimal Corresponding Source or
+// Minimal Application Code as set out in 4d or providing the installation
+// information set out in section 4e, provided that you comply with the other
+// provisions of LGPL3 and provided that you meet, for the Application the
+// terms and conditions of the license(s) which apply to the Application.
+//
+// Except as stated in this special exception, the provisions of LGPL3 will
+// continue to comply in full to this Library. If you modify this Library, you
+// may apply this exception to your version of this Library, but you are not
+// obliged to do so. If you do not wish to do so, delete this exception
+// statement from your version. This exception does not (and cannot) modify any
+// license terms which apply to the Application, with which you must still
+// comply.
+
+#ifndef RICE_QENUM_HPP
+#define RICE_QENUM_HPP
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <QVariant>
+
+using namespace Rice;
+
+template<typename Enum_T>
+Data_Type<Enum_T> define_qenum_under(Module module, char const* name)
+{
+    Data_Type<Enum_T> qenum =
+        define_class_under<Enum_T>(module, name)
+            .template define_method("to_i", [](Enum_T *self) -> int { return (int)(*self); })
+            .define_singleton_function("_qvariant_register_metatype", []() -> int { return qRegisterMetaType<Enum_T>(); })
+            .define_singleton_function("_qvariant_from_value", [](const Enum_T &value) -> QVariant { return QVariant::fromValue(value); })
+            .define_singleton_function("_qvariant_to_value", [](const QVariant &qvariant) -> Enum_T { return qvariant.value<Enum_T>(); });
+    return qenum;
+}
+
+template<typename Enum_T>
+void define_qenum_value_under(Data_Type<Enum_T> qenum, std::string name, Enum_T value)
+{
+    Data_Object<Enum_T> object(value, true, Data_Type<Enum_T>::klass());
+    qenum.const_set(name, object);
+}
+
+#endif

data/include/rice/qt6/qflags.hpp

@@ -0,0 +1,58 @@
+// This file is part of [RubyQt6](https://github.com/souk4711/ruby-qt6).
+//
+// It is licensed under the LGPLv3, included below.
+//
+// As a special exception to the GNU Lesser General Public License version 3
+// ("LGPL3"), the copyright holders of this Library give you permission to
+// convey to a third party a Combined Work that links statically or dynamically
+// to this Library without providing any Minimal Corresponding Source or
+// Minimal Application Code as set out in 4d or providing the installation
+// information set out in section 4e, provided that you comply with the other
+// provisions of LGPL3 and provided that you meet, for the Application the
+// terms and conditions of the license(s) which apply to the Application.
+//
+// Except as stated in this special exception, the provisions of LGPL3 will
+// continue to comply in full to this Library. If you modify this Library, you
+// may apply this exception to your version of this Library, but you are not
+// obliged to do so. If you do not wish to do so, delete this exception
+// statement from your version. This exception does not (and cannot) modify any
+// license terms which apply to the Application, with which you must still
+// comply.
+
+#ifndef RICE_QFLAGS_HPP
+#define RICE_QFLAGS_HPP
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <QFlags>
+
+using namespace Rice;
+
+template<typename Enum_T>
+Data_Type<QFlags<Enum_T>> define_qflags_under(Module module, char const* name)
+{
+    using QFlags_T = QFlags<Enum_T>;
+
+    Data_Type<QFlags_T> qflags = define_class_under<QFlags_T>(module, name)
+        .define_constructor(Constructor<QFlags_T>())
+        .define_constructor(Constructor<QFlags_T, Enum_T>(), Arg("flags"))
+        .template define_method("to_i", [](QFlags_T *self) -> int { return (int)(*self); })
+        .template define_method("~", &QFlags_T::operator~)
+        .template define_method<QFlags_T (QFlags_T::*)(Enum_T) const noexcept>("&", &QFlags_T::operator&, Arg("mask"))
+        .template define_method<QFlags_T (QFlags_T::*)(QFlags_T) const noexcept>("&", &QFlags_T::operator&, Arg("mask"))
+        .template define_method<QFlags_T &(QFlags_T::*)(Enum_T) noexcept>("&=", &QFlags_T::operator&=, Arg("mask"))
+        .template define_method<QFlags_T &(QFlags_T::*)(QFlags_T) noexcept>("&=", &QFlags_T::operator&=, Arg("mask"))
+        .template define_method<QFlags_T (QFlags_T::*)(Enum_T) const noexcept>("^", &QFlags_T::operator^, Arg("other"))
+        .template define_method<QFlags_T (QFlags_T::*)(QFlags_T) const noexcept>("^", &QFlags_T::operator^, Arg("other"))
+        .template define_method<QFlags_T &(QFlags_T::*)(Enum_T) noexcept>("^=", &QFlags_T::operator^=, Arg("other"))
+        .template define_method<QFlags_T &(QFlags_T::*)(QFlags_T) noexcept>("^=", &QFlags_T::operator^=, Arg("other"))
+        .template define_method<QFlags_T (QFlags_T::*)(Enum_T) const noexcept>("|", &QFlags_T::operator|, Arg("other"))
+        .template define_method<QFlags_T (QFlags_T::*)(QFlags_T) const noexcept>("|", &QFlags_T::operator|, Arg("other"))
+        .template define_method<QFlags_T &(QFlags_T::*)(Enum_T) noexcept>("|=", &QFlags_T::operator|=, Arg("other"))
+        .template define_method<QFlags_T &(QFlags_T::*)(QFlags_T) noexcept>("|=", &QFlags_T::operator|=, Arg("other"))
+        .template define_singleton_function("from_int", [](int i) -> QFlags_T { return QFlags_T::fromInt(i); }, Arg("i"));
+    return qflags;
+}
+
+#endif

data/include/rice/qt6/qlist.hpp

@@ -0,0 +1,238 @@
+// This file is part of [RubyQt6](https://github.com/souk4711/ruby-qt6).
+//
+// It is licensed under the LGPLv3, included below.
+//
+// As a special exception to the GNU Lesser General Public License version 3
+// ("LGPL3"), the copyright holders of this Library give you permission to
+// convey to a third party a Combined Work that links statically or dynamically
+// to this Library without providing any Minimal Corresponding Source or
+// Minimal Application Code as set out in 4d or providing the installation
+// information set out in section 4e, provided that you comply with the other
+// provisions of LGPL3 and provided that you meet, for the Application the
+// terms and conditions of the license(s) which apply to the Application.
+//
+// Except as stated in this special exception, the provisions of LGPL3 will
+// continue to comply in full to this Library. If you modify this Library, you
+// may apply this exception to your version of this Library, but you are not
+// obliged to do so. If you do not wish to do so, delete this exception
+// statement from your version. This exception does not (and cannot) modify any
+// license terms which apply to the Application, with which you must still
+// comply.
+
+#ifndef RICE_QLIST_HPP
+#define RICE_QLIST_HPP
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <QList>
+
+using namespace Rice;
+
+template<typename QList_T>
+class DefineQListMethods
+{
+      using Value_T = typename QList_T::value_type;
+      using Parameter_T = typename QList_T::parameter_type;
+
+public:
+    DefineQListMethods(Data_Type<QList_T> klass) : klass_(klass)
+    {
+        this->define_constructors();
+        this->define_constructable_methods();
+        this->define_capacity_methods();
+        this->define_access_methods();
+        this->define_comparable_methods();
+        this->define_insert_methods();
+        this->define_remove_methods();
+        this->define_replace_methods();
+        this->define_enumerable();
+        this->define_to_array();
+        this->define_to_s();
+    }
+
+private:
+    void define_constructors()
+    {
+        klass_.define_constructor(Constructor<QList_T>());
+        klass_.define_constructor(Constructor<QList_T, qsizetype>(), Arg("size"));
+        klass_.define_constructor(Constructor<QList_T, qsizetype, const Parameter_T>(), Arg("size"), Arg("value"));
+        klass_.define_constructor(Constructor<QList_T, const QList_T&>(), Arg("other"));
+    }
+
+    void define_constructable_methods()
+    {
+        klass_.template define_method<void (QList_T::*)(qsizetype)>("resize", &QList_T::resize, Arg("size"));
+        klass_.template define_method<void (QList_T::*)(qsizetype, Parameter_T)>("resize", &QList_T::resize, Arg("size"), Arg("value"));
+    }
+
+    void define_capacity_methods()
+    {
+        klass_.define_method("capacity", &QList_T::capacity);
+        klass_.define_method("empty?", &QList_T::isEmpty);
+        klass_.define_method("length", &QList_T::length);
+        klass_.define_method("max_size", &QList_T::max_size);
+        klass_.define_method("reserve", &QList_T::reserve);
+        klass_.define_method("shrink_to_fit", &QList_T::shrink_to_fit);
+        klass_.define_method("size", &QList_T::size);
+    }
+
+    void define_access_methods()
+    {
+        klass_.define_method("at", [](QList_T *self, qsizetype index) -> std::optional<Value_T> {
+            if (index < 0) {
+                index = index + self->size();
+                if (index < 0) return std::nullopt;
+            } else if (index >= self->size()) {
+                return std::nullopt;
+            }
+            return self->at(index);
+        });
+
+        klass_.define_method("first", [](QList_T *self) -> std::optional<Value_T> {
+            if (self->size() > 0)
+                return self->first();
+            return std::nullopt;
+        });
+
+        klass_.define_method("last", [](QList_T *self) -> std::optional<Value_T> {
+            if (self->size() > 0)
+                return self->last();
+            return std::nullopt;
+        });
+
+        rb_define_alias(klass_, "[]", "at");
+    }
+
+    void define_comparable_methods()
+    {
+        klass_.define_method("count", [](QList_T *self) -> qsizetype {
+            return self->size();
+        });
+        klass_.define_method("count", [](QList_T *self, Parameter_T element) -> qsizetype {
+            return self->count(element);
+        });
+
+        klass_.define_method("include?", [](QList_T *self, Parameter_T element) -> bool {
+            return self->contains(element);
+        });
+
+        klass_.define_method("index", [](QList_T *self, Parameter_T element) -> std::optional<qsizetype> {
+            qsizetype index = self->indexOf(element);
+            if (index != -1)
+                return index;
+            return std::nullopt;
+        });
+    }
+
+    void define_insert_methods()
+    {
+        klass_.define_method("insert", [](QList_T *self, qsizetype index, Parameter_T element) -> QList_T* {
+            if (index < 0) {
+                index = index + self->size() + 1;
+                if (index < 0) throw std::out_of_range("index " + std::to_string(index - 1 - self->size()) + " too small for array; minimum: -" + std::to_string(self->size() + 1));
+            } else if (index > self->size()) {
+                throw std::out_of_range("index " + std::to_string(index) + " too big");
+            }
+            self->insert(index, element);
+            return self;
+        });
+
+        klass_.define_method("push", [](QList_T *self, Parameter_T element) -> QList_T* {
+            self->push_back(element);
+            return self;
+        });
+
+        klass_.define_method("pop", [](QList_T *self) -> std::optional<Value_T> {
+            if (self->size() > 0)
+                return self->takeLast();
+            return std::nullopt;
+        });
+
+        rb_define_alias(klass_, "<<", "push");
+    }
+
+    void define_remove_methods()
+    {
+        klass_.define_method("clear", [](QList_T *self) -> QList_T* {
+            self->clear();
+            return self;
+        });
+
+        klass_.define_method("delete", [](QList_T *self, Parameter_T element) -> std::optional<Value_T> {
+            qsizetype index = self->lastIndexOf(element);
+            if (index != -1) {
+                Value_T result = self->takeAt(index);
+                self->removeAll(element);
+                return result;
+            }
+            return std::nullopt;
+        });
+
+        klass_.define_method("delete_at", [](QList_T *self, qsizetype index) -> std::optional<Value_T> {
+            if (index < 0) {
+                index = index + self->size();
+                if (index < 0) return std::nullopt;
+            } else if (index >= self->size()) {
+                return std::nullopt;
+            }
+            return self->takeAt(index);
+        });
+    }
+
+    void define_replace_methods()
+    {
+        klass_.define_method("[]=", [](QList_T*self, qsizetype index, Parameter_T element) -> Parameter_T {
+            if (index < 0) {
+                index = index + self->size();
+                if (index < 0) throw std::out_of_range("index " + std::to_string(index - self->size()) + " too small for array; minimum: -" + std::to_string(self->size()));
+            } else if (index > self->size()) {
+                throw std::out_of_range("index " + std::to_string(index) + " too big");
+            }
+            if (index == self->size()) {
+                self->push_back(element);
+            } else {
+                self->replace(index, element);
+            }
+            return element;
+        });
+    }
+
+    void define_enumerable()
+    {
+        klass_.include_module(rb_mEnumerable);
+        klass_.define_method("each", [](QList_T *self) -> QList_T* {
+            for (qsizetype i = 0; i < self->size(); i++) {
+                Rice::detail::protect(rb_yield, Rice::detail::to_ruby(self->at(i)));
+            }
+            return self;
+        });
+    }
+
+    void define_to_array()
+    {
+        rb_define_alias(klass_, "to_ary", "to_a");
+    }
+
+    void define_to_s()
+    {
+    }
+
+private:
+    Data_Type<QList_T> klass_;
+};
+
+template <typename Value_T>
+void define_qlist_under(Module module)
+{
+    using QList_T = QList<Value_T>;
+
+    detail::TypeMapper<QList_T> typeMapper;
+    std::string klassName = typeMapper.rubyName();
+    Identifier id(klassName);
+
+    Data_Type<QList_T> qlist = define_class_under<QList_T>(module, id);
+    DefineQListMethods<QList_T> qlist_(qlist);
+}
+
+#endif