ruby-qt6-rice 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f52b717badc2454bf6407e90edd0b0df62c23ee4d2f3e7aeeb8c4397163e78af
-  data.tar.gz: 63cbae54911404f19ed2349edb1240ee071911c6e1da85015920072b1360079b
+  metadata.gz: 2eecacef7953c399d97928b84a9297cbca7e254e1546001334eb34aaed603cf7
+  data.tar.gz: b7332ffa98f413078de378951b053b2b24cbb72d10831772ecd51c1464a07b84
 SHA512:
-  metadata.gz: 406d105280cbdc44d5cc1952c3250de4ca07cebe1ef85a8d63a458925029c96d6bb77c8fdcdbc27972aae4cd446f55f53e4f2ed4e403d9df7dbc186be10bcd4d
-  data.tar.gz: c30c5dac94f1eee0dcf2cea1bbc6c901f6910e68281b9e42573d0a27abd2ed30c2bd6b6871bdc81346c39e436d4cfaf8aba6cf9eee1aa8ebcb05c85501997a72
+  metadata.gz: ce474286a898c50d37a2432a971e8001f4a4e0c763c6951fba66c33e97743be545b56de81add4d3610e9c438b4b6085c106a75e0d78120110de5180e4202f61b
+  data.tar.gz: 43e8f652d16607041567dc2348198f1a7ee0fd0d6fcaaadda9ab95a8acbd75f66b65768c606c1afa705e9cc079351f4eebe61246894284596de3d9bc16f88515

data/.rubocop.yml

@@ -8,8 +8,4 @@ AllCops:
   Exclude:
     - "bin/**/*"
     - "tmp/**/*"
-    - "lib/mkmf-rice.rb"
-
-Style/GlobalVars:
-  AllowedVariables:
-    - '$qApp'
+    - "lib/mkmf-*.rb"

data/include/bando/common.hpp

@@ -22,14 +22,13 @@
 #ifndef BANDO_COMMON_HPP
 #define BANDO_COMMON_HPP
 
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
-
 #include <QEvent>
 #include <QMetaMethod>
 #include <QMetaObject>
 #include <QObject>
 
+RICE4RUBYQT6_USE_NAMESPACE
+
 enum bando_FunctionName
 {
     actionEvent,
@@ -128,19 +127,19 @@ constexpr std::string_view bando_FunctionName_underscore(bando_FunctionName name
     }
 }
 
-template <typename BandoClass_T> void bando_initializeValue(BandoClass_T *self, Rice::Object value, QMetaObject *mo)
+template <typename BandoClass_T> void bando_initializeValue(BandoClass_T *self, Object value, QMetaObject *mo)
 {
     self->value_ = value;
     self->mo_ = mo;
 
     self->value_address_ = const_cast<VALUE*>(&self->value_.value());
-    Rice::detail::protect(rb_gc_register_address, self->value_address_);
+    detail::protect(rb_gc_register_address, self->value_address_);
 }
 
 template <typename BandoClass_T> void bando_finalizer(BandoClass_T *self)
 {
     if (self->value_address_ != nullptr)
-        Rice::detail::protect(rb_gc_unregister_address, self->value_address_);
+        detail::protect(rb_gc_unregister_address, self->value_address_);
 }
 
 template <typename BandoClass_T, typename Class_T> const QMetaObject *bando_metaObject(const BandoClass_T *self)
@@ -170,10 +169,8 @@ template <typename BandoClass_T> int bando_qt_metacall(BandoClass_T *self, QMeta
         }
         if (method.methodType() == QMetaMethod::Slot)
         {
-            auto name = method.name().toStdString();
-            Q_ASSERT(name.rfind("_rubyqt6_", 0) == 0);
-
-            auto arguments = Rice::Array();
+            auto name = "_rubyqt6_slot_" + method.name().toStdString();
+            auto arguments = Array();
             for (int i = 0; i < method.parameterCount(); ++i)
             {
                 QVariant argument(method.parameterMetaType(i), args[i + 1]);
@@ -185,7 +182,7 @@ template <typename BandoClass_T> int bando_qt_metacall(BandoClass_T *self, QMeta
 
             if (method.returnType() != QMetaType::Void) {
                 if (!rb_return.is_nil()) {
-                    const QVariant result = Rice::detail::From_Ruby<QVariant>().convert(rb_return);
+                    const QVariant result = detail::From_Ruby<QVariant>().convert(rb_return);
                     method.returnMetaType().construct(args[0], result.constData());
                 }
             }
@@ -199,34 +196,34 @@ template <typename BandoClass_T> int bando_qt_metacall(BandoClass_T *self, QMeta
 
 template <typename BandoClass_T> bool bando_handleQObjectEvent(BandoClass_T *self, QEvent *event)
 {
-    auto rb_name = Rice::Identifier("event");
+    auto rb_name = Identifier("event");
     if (!self->value_.respond_to(rb_name))
         return self->Class_T_handleQObjectEvent(event);
 
     Q_ASSERT(self->value_.rb_type() != RUBY_T_NONE);
-    auto rb_return = self->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(event)));
-    return Rice::detail::From_Ruby<bool>().convert(rb_return);
+    auto rb_return = self->value_.call(rb_name, Object(detail::to_ruby(event)));
+    return detail::From_Ruby<bool>().convert(rb_return);
 }
 
 template <typename BandoClass_T> bool bando_handleQObjectEventFilter(BandoClass_T *self, QObject *watched, QEvent *event)
 {
-    auto rb_name = Rice::Identifier("event_filter");
+    auto rb_name = Identifier("event_filter");
     if (!self->value_.respond_to(rb_name))
         return self->Class_T_handleQObjectEventFilter(watched, event);
 
     Q_ASSERT(self->value_.rb_type() != RUBY_T_NONE);
-    auto rb_return = self->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(watched)), Rice::Object(Rice::detail::to_ruby(event)));
-    return Rice::detail::From_Ruby<bool>().convert(rb_return);
+    auto rb_return = self->value_.call(rb_name, Object(detail::to_ruby(watched)), Object(detail::to_ruby(event)));
+    return detail::From_Ruby<bool>().convert(rb_return);
 }
 
 template <typename BandoClass_T> void bando_handleEvent(BandoClass_T *self, QEvent *event, bando_FunctionName name)
 {
-    auto rb_name = Rice::Identifier(bando_FunctionName_underscore(name));
+    auto rb_name = Identifier(bando_FunctionName_underscore(name));
     if (!self->value_.respond_to(rb_name))
         return self->Class_T_handleEvent(name, event);
 
     Q_ASSERT(self->value_.rb_type() != RUBY_T_NONE);
-    self->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(event)));
+    self->value_.call(rb_name, Object(detail::to_ruby(event)));
 }
 
 #endif

data/include/bando/qobject/qdbusabstractadaptor.hpp

@@ -27,6 +27,8 @@
 #include <QEvent>
 #include <QTimerEvent>
 
+RICE4RUBYQT6_USE_NAMESPACE
+
 template <typename Class_T, typename... Arg_Ts> class BandoQDBusAbstractAdaptor : public Class_T
 {
   public:
@@ -37,8 +39,8 @@ template <typename Class_T, typename... Arg_Ts> class BandoQDBusAbstractAdaptor
     BandoQDBusAbstractAdaptor &operator=(BandoQDBusAbstractAdaptor &&) = delete;
     ~BandoQDBusAbstractAdaptor() override { bando_finalizer<BandoQDBusAbstractAdaptor>(this); };
 
-    void initializeValue(Rice::Object value, QMetaObject *mo) { bando_initializeValue<BandoQDBusAbstractAdaptor>(this, value, mo); };
-    Rice::Object value() { return this->value_; };
+    void initializeValue(Object value, QMetaObject *mo) { bando_initializeValue<BandoQDBusAbstractAdaptor>(this, value, mo); };
+    Object value() { return this->value_; };
 
     const QMetaObject *metaObject() const override { return bando_metaObject<BandoQDBusAbstractAdaptor, Class_T>(this); };
     int qt_metacall(QMetaObject::Call call, int id, void **args) override { return bando_qt_metacall<BandoQDBusAbstractAdaptor>(this, call, id, args); };
@@ -52,11 +54,11 @@ template <typename Class_T, typename... Arg_Ts> class BandoQDBusAbstractAdaptor
 
     bool autoRelaySignals() const {
         return this->Class_T::autoRelaySignals();
-    }
+    };
 
     void setAutoRelaySignals(bool enable) {
         this->Class_T::setAutoRelaySignals(enable);
-    }
+    };
 
   public:
     bool Class_T_handleQObjectEvent(QEvent *event) { return this->Class_T::event(event); };
@@ -74,27 +76,27 @@ template <typename Class_T, typename... Arg_Ts> class BandoQDBusAbstractAdaptor
   public:
     template <typename BC_T, typename C_T> friend const QMetaObject *bando_metaObject(const BC_T *self);
 
-    Rice::Object value_;
+    Object value_;
     VALUE *value_address_;
 
     QMetaObject *mo_;
 };
 
 template <typename BC_T, typename C_T>
-Rice::Data_Type<BC_T> define_bando_qdbusabstractadaptor_under(Rice::Module module, char const *name)
+Data_Type<BC_T> define_bando_qdbusabstractadaptor_under(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"))
+    Data_Type<BC_T> bando_qlass =
+        define_class_under<BC_T, C_T>(module, name)
+            .define_method("_initialize_ruby_value", &BC_T::initializeValue, Arg("value"), 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("_ruby_value_handle_event", &BC_T::Class_T_handleEvent, Arg("name"), Arg("event"))
+            .define_method("_event", &BC_T::Class_T_handleQObjectEvent, Arg("event"))
+            .define_method("_event_filter", &BC_T::Class_T_handleQObjectEventFilter, Arg("watched"), Arg("event"))
             .define_method("sender", &BC_T::sender);
 
     bando_qlass
         .define_method("auto_relay_signals", &BC_T::autoRelaySignals)
-        .define_method("set_auto_relay_signals", &BC_T::setAutoRelaySignals, Rice::Arg("enable"));
+        .define_method("set_auto_relay_signals", &BC_T::setAutoRelaySignals, Arg("enable"));
 
     return bando_qlass;
 }

data/include/bando/qobject/qdbusabstractinterface.hpp

@@ -27,6 +27,8 @@
 #include <QEvent>
 #include <QTimerEvent>
 
+RICE4RUBYQT6_USE_NAMESPACE
+
 template <typename Class_T, typename... Arg_Ts> class BandoQDBusAbstractInterface : public Class_T
 {
   public:
@@ -37,8 +39,8 @@ template <typename Class_T, typename... Arg_Ts> class BandoQDBusAbstractInterfac
     BandoQDBusAbstractInterface &operator=(BandoQDBusAbstractInterface &&) = delete;
     ~BandoQDBusAbstractInterface() override { bando_finalizer<BandoQDBusAbstractInterface>(this); };
 
-    void initializeValue(Rice::Object value, QMetaObject *mo) { bando_initializeValue<BandoQDBusAbstractInterface>(this, value, mo); };
-    Rice::Object value() { return this->value_; };
+    void initializeValue(Object value, QMetaObject *mo) { bando_initializeValue<BandoQDBusAbstractInterface>(this, value, mo); };
+    Object value() { return this->value_; };
 
     const QMetaObject *metaObject() const override { return bando_metaObject<BandoQDBusAbstractInterface, Class_T>(this); };
     int qt_metacall(QMetaObject::Call call, int id, void **args) override { return bando_qt_metacall<BandoQDBusAbstractInterface>(this, call, id, args); };
@@ -66,22 +68,22 @@ template <typename Class_T, typename... Arg_Ts> class BandoQDBusAbstractInterfac
   public:
     template <typename BC_T, typename C_T> friend const QMetaObject *bando_metaObject(const BC_T *self);
 
-    Rice::Object value_;
+    Object value_;
     VALUE *value_address_;
 
     QMetaObject *mo_;
 };
 
 template <typename BC_T, typename C_T>
-Rice::Data_Type<BC_T> define_bando_qdbusabstractinterface_under(Rice::Module module, char const *name)
+Data_Type<BC_T> define_bando_qdbusabstractinterface_under(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"))
+    Data_Type<BC_T> bando_qlass =
+        define_class_under<BC_T, C_T>(module, name)
+            .define_method("_initialize_ruby_value", &BC_T::initializeValue, Arg("value"), 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("_ruby_value_handle_event", &BC_T::Class_T_handleEvent, Arg("name"), Arg("event"))
+            .define_method("_event", &BC_T::Class_T_handleQObjectEvent, Arg("event"))
+            .define_method("_event_filter", &BC_T::Class_T_handleQObjectEventFilter, Arg("watched"), Arg("event"))
             .define_method("sender", &BC_T::sender);
     return bando_qlass;
 }

data/include/bando/qobject/qitemdelegate.hpp

@@ -29,6 +29,8 @@
 #include <QStyleOptionViewItem>
 #include <QTimerEvent>
 
+RICE4RUBYQT6_USE_NAMESPACE
+
 template <typename Class_T, typename... Arg_Ts> class BandoQItemDelegate : public Class_T
 {
   public:
@@ -39,8 +41,8 @@ template <typename Class_T, typename... Arg_Ts> class BandoQItemDelegate : publi
     BandoQItemDelegate &operator=(BandoQItemDelegate &&) = delete;
     ~BandoQItemDelegate() override { bando_finalizer<BandoQItemDelegate>(this); };
 
-    void initializeValue(Rice::Object value, QMetaObject *mo) { bando_initializeValue<BandoQItemDelegate>(this, value, mo); };
-    Rice::Object value() { return this->value_; };
+    void initializeValue(Object value, QMetaObject *mo) { bando_initializeValue<BandoQItemDelegate>(this, value, mo); };
+    Object value() { return this->value_; };
 
     const QMetaObject *metaObject() const override { return bando_metaObject<BandoQItemDelegate, Class_T>(this); };
     int qt_metacall(QMetaObject::Call call, int id, void **args) override { return bando_qt_metacall<BandoQItemDelegate>(this, call, id, args); };
@@ -54,41 +56,41 @@ template <typename Class_T, typename... Arg_Ts> class BandoQItemDelegate : publi
 
     QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("create_editor");
-        auto rb_return = this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(parent)), Rice::Object(Rice::detail::to_ruby(option)), Rice::Object(Rice::detail::to_ruby(index)));
-        return Rice::detail::From_Ruby<QWidget *>().convert(rb_return);
+        auto rb_name = Identifier("create_editor");
+        auto rb_return = this->value_.call(rb_name, Object(detail::to_ruby(parent)), Object(detail::to_ruby(option)), Object(detail::to_ruby(index)));
+        return detail::From_Ruby<QWidget *>().convert(rb_return);
     };
 
     void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("paint");
-        this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(painter)), Rice::Object(Rice::detail::to_ruby(option)), Rice::Object(Rice::detail::to_ruby(index)));
-    }
+        auto rb_name = Identifier("paint");
+        this->value_.call(rb_name, Object(detail::to_ruby(painter)), Object(detail::to_ruby(option)), Object(detail::to_ruby(index)));
+    };
 
     void setEditorData(QWidget *editor, const QModelIndex &index) const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("set_editor_data");
-        this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(editor)), Rice::Object(Rice::detail::to_ruby(index)));
-    }
+        auto rb_name = Identifier("set_editor_data");
+        this->value_.call(rb_name, Object(detail::to_ruby(editor)), Object(detail::to_ruby(index)));
+    };
 
     void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("set_model_data");
-        this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(editor)), Rice::Object(Rice::detail::to_ruby(model)), Rice::Object(Rice::detail::to_ruby(index)));
-    }
+        auto rb_name = Identifier("set_model_data");
+        this->value_.call(rb_name, Object(detail::to_ruby(editor)), Object(detail::to_ruby(model)), Object(detail::to_ruby(index)));
+    };
 
     QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) 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, Rice::Object(Rice::detail::to_ruby(option)), Rice::Object(Rice::detail::to_ruby(index)));
-        return Rice::detail::From_Ruby<QSize>().convert(rb_return);
-    }
+        auto rb_name = Identifier("size_hint");
+        auto rb_return = this->value_.call(rb_name, Object(detail::to_ruby(option)), Object(detail::to_ruby(index)));
+        return detail::From_Ruby<QSize>().convert(rb_return);
+    };
 
     void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("update_editor_geometry");
-        this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(editor)), Rice::Object(Rice::detail::to_ruby(option)), Rice::Object(Rice::detail::to_ruby(index)));
-    }
+        auto rb_name = Identifier("update_editor_geometry");
+        this->value_.call(rb_name, Object(detail::to_ruby(editor)), Object(detail::to_ruby(option)), Object(detail::to_ruby(index)));
+    };
 
   public:
     bool Class_T_handleQObjectEvent(QEvent *event) { return this->Class_T::event(event); };
@@ -106,31 +108,31 @@ template <typename Class_T, typename... Arg_Ts> class BandoQItemDelegate : publi
   public:
     template <typename BC_T, typename C_T> friend const QMetaObject *bando_metaObject(const BC_T *self);
 
-    Rice::Object value_;
+    Object value_;
     VALUE *value_address_;
 
     QMetaObject *mo_;
 };
 
 template <typename BC_T, typename C_T>
-Rice::Data_Type<BC_T> define_bando_qitemdelegate_under(Rice::Module module, char const *name)
+Data_Type<BC_T> define_bando_qitemdelegate_under(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"))
+    Data_Type<BC_T> bando_qlass =
+        define_class_under<BC_T, C_T>(module, name)
+            .define_method("_initialize_ruby_value", &BC_T::initializeValue, Arg("value"), 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("_ruby_value_handle_event", &BC_T::Class_T_handleEvent, Arg("name"), Arg("event"))
+            .define_method("_event", &BC_T::Class_T_handleQObjectEvent, Arg("event"))
+            .define_method("_event_filter", &BC_T::Class_T_handleQObjectEventFilter, Arg("watched"), Arg("event"))
             .define_method("sender", &BC_T::sender);
 
     bando_qlass
-        .define_method("create_editor", [](BC_T *self, QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) -> QWidget * { return self->C_T::createEditor(parent, option, index); })
-        .define_method("paint", [](BC_T *self, QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) -> void { return self->C_T::paint(painter, option, index); })
-        .define_method("set_editor_data", [](BC_T *self, QWidget *editor, const QModelIndex &index) -> void { return self->C_T::setEditorData(editor, index); })
-        .define_method("set_model_data", [](BC_T *self, QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) -> void { return self->C_T::setModelData(editor, model, index); })
-        .define_method("size_hint", [](BC_T *self, const QStyleOptionViewItem &option, const QModelIndex &index) -> QSize { return self->C_T::sizeHint(option, index); })
-        .define_method("update_editor_geometry", [](BC_T *self, QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) -> void { return self->C_T::updateEditorGeometry(editor, option, index); });
+        .define_method("create_editor", [](BC_T *self, QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) -> QWidget * { return self->C_T::createEditor(parent, option, index); }, Arg("parent"), Arg("option"), Arg("index"))
+        .define_method("paint", [](BC_T *self, QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) -> void { return self->C_T::paint(painter, option, index); }, Arg("painter"), Arg("option"), Arg("index"))
+        .define_method("set_editor_data", [](BC_T *self, QWidget *editor, const QModelIndex &index) -> void { return self->C_T::setEditorData(editor, index); }, Arg("editor"), Arg("index"))
+        .define_method("set_model_data", [](BC_T *self, QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) -> void { return self->C_T::setModelData(editor, model, index); }, Arg("editor"), Arg("model"), Arg("index"))
+        .define_method("size_hint", [](BC_T *self, const QStyleOptionViewItem &option, const QModelIndex &index) -> QSize { return self->C_T::sizeHint(option, index); }, Arg("option"), Arg("index"))
+        .define_method("update_editor_geometry", [](BC_T *self, QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) -> void { return self->C_T::updateEditorGeometry(editor, option, index); }, Arg("editor"), Arg("option"), Arg("index"));
 
     return bando_qlass;
 }

data/include/bando/qobject/qlayout.hpp

@@ -29,6 +29,8 @@
 #include <QTimerEvent>
 #include <QWidget>
 
+RICE4RUBYQT6_USE_NAMESPACE
+
 template <typename Class_T, typename... Arg_Ts> class BandoQLayout : public Class_T
 {
   public:
@@ -39,8 +41,8 @@ template <typename Class_T, typename... Arg_Ts> class BandoQLayout : public Clas
     BandoQLayout &operator=(BandoQLayout &&) = delete;
     ~BandoQLayout() override { bando_finalizer<BandoQLayout>(this); };
 
-    void initializeValue(Rice::Object value, QMetaObject *mo) { bando_initializeValue<BandoQLayout>(this, value, mo); };
-    Rice::Object value() { return this->value_; };
+    void initializeValue(Object value, QMetaObject *mo) { bando_initializeValue<BandoQLayout>(this, value, mo); };
+    Object value() { return this->value_; };
 
     const QMetaObject *metaObject() const override { return bando_metaObject<BandoQLayout, Class_T>(this); };
     int qt_metacall(QMetaObject::Call call, int id, void **args) override { return bando_qt_metacall<BandoQLayout>(this, call, id, args); };
@@ -54,78 +56,78 @@ template <typename Class_T, typename... Arg_Ts> class BandoQLayout : public Clas
 
     void addItem(QLayoutItem *item) override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("add_item");
-        this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(item)));
+        auto rb_name = Identifier("add_item");
+        this->value_.call(rb_name, Object(detail::to_ruby(item)));
     };
 
     int count() const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("count");
+        auto rb_name = Identifier("count");
         auto rb_return = this->value_.call(rb_name);
-        return Rice::detail::From_Ruby<int>().convert(rb_return);
+        return detail::From_Ruby<int>().convert(rb_return);
     };
 
     QLayoutItem *itemAt(int index) const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("item_at");
-        auto rb_return = this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(index)));
-        return Rice::detail::From_Ruby<QLayoutItem *>().convert(rb_return);
+        auto rb_name = Identifier("item_at");
+        auto rb_return = this->value_.call(rb_name, Object(detail::to_ruby(index)));
+        return detail::From_Ruby<QLayoutItem *>().convert(rb_return);
     };
 
     QLayoutItem *takeAt(int index) override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("take_at");
-        auto rb_return = this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(index)));
-        return Rice::detail::From_Ruby<QLayoutItem *>().convert(rb_return);
+        auto rb_name = Identifier("take_at");
+        auto rb_return = this->value_.call(rb_name, Object(detail::to_ruby(index)));
+        return detail::From_Ruby<QLayoutItem *>().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_name = Identifier("size_hint");
         auto rb_return = this->value_.call(rb_name);
-        return Rice::detail::From_Ruby<QSize>().convert(rb_return);
+        return detail::From_Ruby<QSize>().convert(rb_return);
     };
 
     Qt::Orientations expandingDirections() const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("expanding_directions");
+        auto rb_name = Identifier("expanding_directions");
         auto rb_return = this->value_.call(rb_name);
-        return Rice::detail::From_Ruby<Qt::Orientations>().convert(rb_return);
+        return detail::From_Ruby<Qt::Orientations>().convert(rb_return);
     };
 
     bool hasHeightForWidth() const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("has_height_for_width");
+        auto rb_name = Identifier("has_height_for_width");
         auto rb_return = this->value_.call(rb_name);
-        return Rice::detail::From_Ruby<bool>().convert(rb_return);
+        return detail::From_Ruby<bool>().convert(rb_return);
     };
 
     int heightForWidth(int width) const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("height_for_width");
-        auto rb_return = this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(width)));
-        return Rice::detail::From_Ruby<int>().convert(rb_return);
+        auto rb_name = Identifier("height_for_width");
+        auto rb_return = this->value_.call(rb_name, Object(detail::to_ruby(width)));
+        return detail::From_Ruby<int>().convert(rb_return);
     };
 
     QSize maximumSize() const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("maximum_size");
+        auto rb_name = Identifier("maximum_size");
         auto rb_return = this->value_.call(rb_name);
-        return Rice::detail::From_Ruby<QSize>().convert(rb_return);
+        return detail::From_Ruby<QSize>().convert(rb_return);
     };
 
     QSize minimumSize() const override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("minimum_size");
+        auto rb_name = Identifier("minimum_size");
         auto rb_return = this->value_.call(rb_name);
-        return Rice::detail::From_Ruby<QSize>().convert(rb_return);
+        return detail::From_Ruby<QSize>().convert(rb_return);
     };
 
     void setGeometry(const QRect &r) override {
         Q_ASSERT(this->value_.rb_type() != RUBY_T_NONE);
-        auto rb_name = Rice::Identifier("set_geometry");
-        this->value_.call(rb_name, Rice::Object(Rice::detail::to_ruby(r)));
-    }
+        auto rb_name = Identifier("set_geometry");
+        this->value_.call(rb_name, Object(detail::to_ruby(r)));
+    };
 
   public:
     bool Class_T_handleQObjectEvent(QEvent *event) { return this->Class_T::event(event); };
@@ -143,31 +145,31 @@ template <typename Class_T, typename... Arg_Ts> class BandoQLayout : public Clas
   public:
     template <typename BC_T, typename C_T> friend const QMetaObject *bando_metaObject(const BC_T *self);
 
-    Rice::Object value_;
+    Object value_;
     VALUE *value_address_;
 
     QMetaObject *mo_;
 };
 
 template <typename BC_T, typename C_T>
-Rice::Data_Type<BC_T> define_bando_qlayout_under(Rice::Module module, char const *name)
+Data_Type<BC_T> define_bando_qlayout_under(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"))
+    Data_Type<BC_T> bando_qlass =
+        define_class_under<BC_T, C_T>(module, name)
+            .define_method("_initialize_ruby_value", &BC_T::initializeValue, Arg("value"), 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("_ruby_value_handle_event", &BC_T::Class_T_handleEvent, Arg("name"), Arg("event"))
+            .define_method("_event", &BC_T::Class_T_handleQObjectEvent, Arg("event"))
+            .define_method("_event_filter", &BC_T::Class_T_handleQObjectEventFilter, Arg("watched"), Arg("event"))
             .define_method("sender", &BC_T::sender);
 
     bando_qlass
         .define_method("expanding_directions", [](BC_T *self) -> Qt::Orientations { return self->C_T::expandingDirections(); })
         .define_method("has_height_for_width", [](BC_T *self) -> bool { return self->C_T::hasHeightForWidth(); })
-        .define_method("height_for_width", [](BC_T *self, int width) -> int { return self->C_T::heightForWidth(width); })
+        .define_method("height_for_width", [](BC_T *self, int width) -> int { return self->C_T::heightForWidth(width); }, Arg("width"))
         .define_method("maximum_size", [](BC_T *self) -> QSize { return self->C_T::maximumSize(); })
         .define_method("minimum_size", [](BC_T *self) -> QSize { return self->C_T::minimumSize(); })
-        .define_method("set_geometry", [](BC_T *self, const QRect &r) -> void { return self->C_T::setGeometry(r); });
+        .define_method("set_geometry", [](BC_T *self, const QRect &r) -> void { return self->C_T::setGeometry(r); }, Arg("r"));
 
     return bando_qlass;
 }