ruby-qt6-qtcore 1.0.0

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

@@ -0,0 +1,60 @@
+#include "quuid-rb.hpp"
+#include <quuid.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQUuid;
+
+int QUuid_operator_compare(QUuid *lhs, QUuid *rhs)
+{
+    if (*lhs < *rhs) return -1;
+    if (*lhs > *rhs) return  1;
+    return 0;
+}
+
+void Init_quuid(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQUuid =
+        // RubyQt6::QtCore::QUuid
+        define_class_under<QUuid>(rb_mQt6QtCore, "QUuid")
+            // RubyQt6-Defined Functions
+            .define_method("variant", [](QUuid *self) -> QUuid::Variant { return self->variant(); })
+            .define_method("version", [](QUuid *self) -> QUuid::Version { return self->version(); })
+            .define_singleton_function("_operator_compare", QUuid_operator_compare, Arg("lhs"), Arg("rhs"))
+            // Constructor
+            .define_constructor(Constructor<QUuid>())
+            .define_constructor(Constructor<QUuid, QAnyStringView>(), Arg("string"))
+            // Public Functions
+            .define_method("null?", &QUuid::isNull)
+            .define_method("to_byte_array", &QUuid::toByteArray, Arg("mode") = static_cast<QUuid::StringFormat>(QUuid::StringFormat::WithBraces))
+            .define_method("to_string", &QUuid::toString, Arg("mode") = static_cast<QUuid::StringFormat>(QUuid::StringFormat::WithBraces));
+
+    Data_Type<QUuid::StringFormat> rb_cQUuidStringFormat =
+        // RubyQt6::QtCore::QUuid::StringFormat
+        define_qenum_under<QUuid::StringFormat>(rb_cQUuid, "StringFormat");
+        define_qenum_value_under(rb_cQUuidStringFormat, "WithBraces", QUuid::StringFormat::WithBraces);
+        define_qenum_value_under(rb_cQUuidStringFormat, "WithoutBraces", QUuid::StringFormat::WithoutBraces);
+        define_qenum_value_under(rb_cQUuidStringFormat, "Id128", QUuid::StringFormat::Id128);
+
+    Data_Type<QUuid::Variant> rb_cQUuidVariant =
+        // RubyQt6::QtCore::QUuid::Variant
+        define_qenum_under<QUuid::Variant>(rb_cQUuid, "Variant");
+        define_qenum_value_under(rb_cQUuidVariant, "VarUnknown", QUuid::Variant::VarUnknown);
+        define_qenum_value_under(rb_cQUuidVariant, "NCS", QUuid::Variant::NCS);
+        define_qenum_value_under(rb_cQUuidVariant, "DCE", QUuid::Variant::DCE);
+        define_qenum_value_under(rb_cQUuidVariant, "Microsoft", QUuid::Variant::Microsoft);
+        define_qenum_value_under(rb_cQUuidVariant, "Reserved", QUuid::Variant::Reserved);
+
+    Data_Type<QUuid::Version> rb_cQUuidVersion =
+        // RubyQt6::QtCore::QUuid::Version
+        define_qenum_under<QUuid::Version>(rb_cQUuid, "Version");
+        define_qenum_value_under(rb_cQUuidVersion, "VerUnknown", QUuid::Version::VerUnknown);
+        define_qenum_value_under(rb_cQUuidVersion, "Time", QUuid::Version::Time);
+        define_qenum_value_under(rb_cQUuidVersion, "EmbeddedPOSIX", QUuid::Version::EmbeddedPOSIX);
+        define_qenum_value_under(rb_cQUuidVersion, "Md5", QUuid::Version::Md5);
+        define_qenum_value_under(rb_cQUuidVersion, "Name", QUuid::Version::Name);
+        define_qenum_value_under(rb_cQUuidVersion, "Random", QUuid::Version::Random);
+        define_qenum_value_under(rb_cQUuidVersion, "Sha1", QUuid::Version::Sha1);
+        define_qenum_value_under(rb_cQUuidVersion, "UnixEpoch", QUuid::Version::UnixEpoch);
+}

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

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

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

@@ -0,0 +1,70 @@
+#include "qvariant-rb.hpp"
+#include <qvariant.h>
+
+#include <QString>
+#include <QDateTime>
+#include <QDate>
+#include <QTime>
+#include <QLine>
+#include <QLineF>
+#include <QPoint>
+#include <QPointF>
+#include <QRect>
+#include <QRectF>
+#include <QSizeF>
+#include <QSizeF>
+
+using namespace Rice;
+
+Rice::Class rb_cQVariant;
+
+void Init_qvariant(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQVariant =
+        // RubyQt6::QtCore::QVariant
+        define_class_under<QVariant>(rb_mQt6QtCore, "QVariant")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("from_bool", [](bool value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_int", [](int value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_double", [](double value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qstring", [](const char *value) -> QVariant { return QVariant(QString(value)); })
+            .define_singleton_function("from_qstring", [](const QString &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qdatetime", [](const QDateTime &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qdate", [](const QDate &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qtime", [](const QTime &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qline", [](const QLine &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qlinef", [](const QLine &value) -> QVariant { return QVariant(QLineF(value)); })
+            .define_singleton_function("from_qlinef", [](const QLineF &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qpoint", [](const QPoint &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qpointf", [](const QPoint &value) -> QVariant { return QVariant(QPointF(value)); })
+            .define_singleton_function("from_qpointf", [](const QPointF &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qrect", [](const QRect &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qrectf", [](const QRect &value) -> QVariant { return QVariant(QRectF(value)); })
+            .define_singleton_function("from_qrectf", [](const QRectF &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qsize", [](const QSize &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qsizef", [](const QSize &value) -> QVariant { return QVariant(QSizeF(value)); })
+            .define_singleton_function("from_qsizef", [](const QSizeF &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qstringlist", [](const QStringList &value) -> QVariant { return QVariant(value); })
+            .define_singleton_function("from_qobject", [](QObject *value) -> QVariant { return QVariant::fromValue(value); })
+            .define_singleton_function("to_bool", [](const QVariant &qvariant) -> bool { return qvariant.toBool(); })
+            .define_singleton_function("to_int", [](const QVariant &qvariant) -> int { return qvariant.toInt(); })
+            .define_singleton_function("to_double", [](const QVariant &qvariant) -> double { return qvariant.toDouble(); })
+            .define_singleton_function("to_qstring", [](const QVariant &qvariant) -> QString { return qvariant.toString(); })
+            .define_singleton_function("to_qdatetime", [](const QVariant &qvariant) -> QDateTime { return qvariant.toDateTime(); })
+            .define_singleton_function("to_qdate", [](const QVariant &qvariant) -> QDate { return qvariant.toDate(); })
+            .define_singleton_function("to_qtime", [](const QVariant &qvariant) -> QTime { return qvariant.toTime(); })
+            .define_singleton_function("to_qline", [](const QVariant &qvariant) -> QLine { return qvariant.toLine(); })
+            .define_singleton_function("to_qlinef", [](const QVariant &qvariant) -> QLineF { return qvariant.toLineF(); })
+            .define_singleton_function("to_qpoint", [](const QVariant &qvariant) -> QPoint { return qvariant.toPoint(); })
+            .define_singleton_function("to_qpointf", [](const QVariant &qvariant) -> QPointF { return qvariant.toPointF(); })
+            .define_singleton_function("to_qrect", [](const QVariant &qvariant) -> QRect { return qvariant.toRect(); })
+            .define_singleton_function("to_qrectf", [](const QVariant &qvariant) -> QRectF { return qvariant.toRectF(); })
+            .define_singleton_function("to_qsize", [](const QVariant &qvariant) -> QSize { return qvariant.toSize(); })
+            .define_singleton_function("to_qsizef", [](const QVariant &qvariant) -> QSizeF { return qvariant.toSizeF(); })
+            .define_singleton_function("to_qstringlist", [](const QVariant &qvariant) -> QStringList { return qvariant.toStringList(); })
+            .define_singleton_function("_to_qobject", [](const QVariant &qvariant) -> QObject * { return qvariant.value<QObject *>(); })
+            // Public Functions
+            .define_method("valid?", &QVariant::isValid)
+            .define_method("type_id", &QVariant::typeId)
+            .define_method("type_name", &QVariant::typeName);
+}

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

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

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

@@ -0,0 +1,31 @@
+#include "t-qtcore-rb.hpp"
+#include <rice/qt6/qlist.hpp>
+
+#include <QItemSelectionRange>
+#include <QModelIndex>
+#include <QObject>
+#include <QString>
+#include <QVariant>
+
+using namespace Rice;
+
+void Init_t_qtcore(Rice::Module rb_mQt6T)
+{
+    // QList<QByteArray>
+    define_qlist_under<QByteArray>(rb_mQt6T);
+
+    // QList<QItemSelectionRange> -> QItemSelection
+    define_qlist_under<QItemSelectionRange>(rb_mQt6T);
+
+    // QList<QModelIndex> -> QModelIndexList
+    define_qlist_under<QModelIndex>(rb_mQt6T);
+
+    // QList<QObject *>
+    define_qlist_under<QObject *>(rb_mQt6T);
+
+    // QList<QString> -> QStringList
+    define_qlist_under<QString>(rb_mQt6T);
+
+    // QList<QVariant>
+    define_qlist_under<QVariant>(rb_mQt6T);
+}

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

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

data/lib/qt6/bando/dsl.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module Bando
+    # @!visibility private
+    def self.define_bando_qobject(qlass)
+      unless qlass <= QtCore::QObject
+        raise "Invalid superclass: macro `define_bando_qobject` " \
+          "only available for subclass of RubyQt6::QtCore::QObject"
+      end
+
+      define_bando_qlass(qlass) do
+        {
+          child_event: FunctionName::ChildEvent,
+          timer_event: FunctionName::TimerEvent
+        }.each do |meth, fn|
+          define_method("_#{meth}") do |event|
+            _ruby_value_handle_event(fn, event)
+          end
+        end
+      end
+    end
+
+    # @!visibility private
+    def self.define_bando_qwidget(qlass)
+      unless qlass <= QtWidgets::QWidget
+        raise "Invalid superclass: macro `define_bando_qwidget` " \
+          "only available for subclass of RubyQt6::QtWidgets::QWidget"
+      end
+
+      define_bando_qlass(qlass) do
+        {
+          child_event: FunctionName::ChildEvent,
+          timer_event: FunctionName::TimerEvent,
+          action_event: FunctionName::ActionEvent,
+          change_event: FunctionName::ChangeEvent,
+          close_event: FunctionName::CloseEvent,
+          context_menu_event: FunctionName::ContextMenuEvent,
+          drag_enter_event: FunctionName::DragEnterEvent,
+          drag_leave_event: FunctionName::DragLeaveEvent,
+          drag_move_event: FunctionName::DragMoveEvent,
+          drop_event: FunctionName::DropEvent,
+          enter_event: FunctionName::EnterEvent,
+          focus_in_event: FunctionName::FocusInEvent,
+          focus_out_event: FunctionName::FocusOutEvent,
+          hide_event: FunctionName::HideEvent,
+          input_method_event: FunctionName::InputMethodEvent,
+          key_press_event: FunctionName::KeyPressEvent,
+          key_release_event: FunctionName::KeyReleaseEvent,
+          leave_event: FunctionName::LeaveEvent,
+          mouse_double_click_event: FunctionName::MouseDoubleClickEvent,
+          mouse_move_event: FunctionName::MouseMoveEvent,
+          mouse_press_event: FunctionName::MousePressEvent,
+          mouse_release_event: FunctionName::MouseReleaseEvent,
+          move_event: FunctionName::MoveEvent,
+          paint_event: FunctionName::PaintEvent,
+          resize_event: FunctionName::ResizeEvent,
+          show_event: FunctionName::ShowEvent,
+          tablet_event: FunctionName::TabletEvent,
+          wheel_event: FunctionName::WheelEvent
+        }.each do |meth, fn|
+          define_method("_#{meth}") do |event|
+            _ruby_value_handle_event(fn, event)
+          end
+        end
+      end
+    end
+
+    # @!visibility private
+    def self.define_bando_qlass(qlass, &blk)
+      qlass.class_eval do
+        alias_method :_initialize, :initialize
+
+        def initialize(*args)
+          super
+          _initialize_ruby_value(self, self.class._qmetaobject)
+        end
+
+        def self._qmetaobject
+          superclass._qmetaobject
+        end
+
+        def self._rubyqt6_metaobject
+          superclass._rubyqt6_metaobject
+        end
+      end
+      qlass.class_eval(&blk)
+    end
+    private_class_method :define_bando_qlass
+  end
+end

data/lib/qt6/bando/qobject.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module Bando
+    class QObject < RubyQt6::QtCore::QObject
+      Bando.define_bando_qobject Bando::QObject
+    end
+  end
+end

data/lib/qt6/configuration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  # @!visibility private
+  def self.load_defaults
+    mods = RubyQt6.constants.grep(/^Qt/).map { |const| RubyQt6.const_get(const) }
+    mods.each do |mod|
+      mod.constants.each do |const|
+        next if const.match?("VERSION")
+        Object.const_set(const, mod.const_get(const)) if const.start_with?("Q")
+      end
+    end
+
+    true
+  end
+end

data/lib/qt6/ducktyping.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  # @!visibility private
+  module T
+    def self.args_nth_delete_qobject(args, index)
+      return unless args[index].is_a?(QtCore::QObject)
+      args.delete_at(index)
+    end
+
+    def self.args_nth_delete_qwidget(args, index)
+      return unless args[index].is_a?(QtWidgets::QWidget)
+      args.delete_at(index)
+    end
+
+    def self.args_nth_delete_qgraphicsitem(args, index)
+      return unless args[index].is_a?(QtWidgets::QGraphicsItem)
+      args.delete_at(index)
+    end
+
+    def self.args_nth_to_qanystringview(args, index)
+      return unless args[index].is_a?(String) || args[index].is_a?(QtCore::QString)
+      args[index] = QtCore::QAnyStringView.new(args[index])
+    end
+
+    def self.args_nth_to_qstr(args, index)
+      return unless args[index].is_a?(String)
+      args[index] = QtCore::QString.new(args[index])
+    end
+
+    def self.to_qanystringview(str)
+      return str unless str.is_a?(String) || str.is_a?(QtCore::QString)
+      QtCore::QAnyStringView.new(str)
+    end
+
+    def self.to_qbytearray(str)
+      return str unless str.is_a?(String)
+      QtCore::QByteArray.new(str)
+    end
+
+    def self.to_qstr(str)
+      return str unless str.is_a?(String)
+      QtCore::QString.new(str)
+    end
+
+    def self.to_qvariantlist(array)
+      array.each_with_object(T::QList≺QVariant≻.new) do |o, memo|
+        memo << (o.is_a?(QtCore::QVariant) ? o : QtCore::QVariant.new(o))
+      end
+    end
+
+    def self.to_qflags(enum_or_flags)
+      return enum_or_flags unless enum_or_flags.respond_to?(:to_qflags)
+      enum_or_flags.to_qflags
+    end
+
+    def self.bando_qobject_cast(object)
+      return object unless object.class.name.start_with?("RubyQt6::Bando::")
+      object._ruby_value
+    end
+
+    def self.inspect_struct(object, **attributes)
+      name = object.class.name.split("::").last + " "
+      attributes = Array(attributes).map { |(name, value)| "#{name}=#{value.inspect}" }.join(", ")
+      ["#<", name, attributes, ">"].join
+    end
+
+    def self.inspect_struct_enum(object, **attributes)
+      name = object.class.name.split("::").last(2).join("::") + " "
+      attributes = Array(attributes).map { |(name, value)| "#{name}=#{value.inspect}" }.join(", ")
+      ["#<", name, attributes, ">"].join
+    end
+  end
+end

data/lib/qt6/qtcore/private/_nodoc.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @!visibility private
+    module Private
+    end
+  end
+end

data/lib/qt6/qtcore/private/inflector.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    module Private
+      class Inflector
+        def camelize(str)
+          str = str.dup
+          str.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+          str
+        end
+
+        def underscore(str)
+          str = str.dup
+          str.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+          str.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          str.downcase!
+          str
+        end
+      end
+
+      def self.inflector
+        @inflector ||= QtCore::Private::Inflector.new
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/private/metamethod.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    module Private
+      class MetaMethod
+        RE = /(\w+ )?(\w+)\((.*)\)/
+
+        attr_reader :name
+        attr_reader :parameters
+        attr_reader :signature
+        attr_reader :return_type
+        attr_reader :type
+
+        def self.normalized_name(name)
+          QtCore::Private.inflector.underscore(name)
+        end
+
+        def self.normalized_parameters(parameters)
+          parameters.map(&->(param) { param.delete(" ") })
+        end
+
+        def self.normalized_signature(normalized_name, normalized_parameters)
+          normalized_name + "(" + normalized_parameters.join(",") + ")"
+        end
+
+        def self.normalized_return_type(return_type)
+          return nil if return_type.nil?
+          return_type.delete(" ")
+        end
+
+        def initialize(signature, type, underlying)
+          matched = signature.match(RE)
+          raise "Invalid metamethod signature: #{signature}" if matched.nil?
+
+          @name = self.class.normalized_name(matched[2])
+          @parameters = self.class.normalized_parameters(matched[3].split(","))
+          @signature = self.class.normalized_signature(@name, @parameters)
+          @return_type = self.class.normalized_return_type(matched[1])
+          @type = type.to_sym
+          @underlying = underlying.to_sym
+        end
+
+        def signal?
+          @type == :signal
+        end
+
+        def slot?
+          @type == :slot
+        end
+
+        def qsignature
+          signature = self.class.normalized_signature(qsignature_name, @parameters)
+          signal? ? "2#{signature}" : "1#{signature}"
+        end
+
+        def qsignature_name
+          case @underlying
+          when :libQt6 then QtCore::Private.inflector.camelize(@name)
+          when :ruby then "_rubyqt6_#{QtCore::Private.inflector.underscore(@name)}"
+          else raise "Unknown underlying type: #{@underlying}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/private/metaobject.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    module Private
+      class MetaObject
+        attr_reader :metamethods
+
+        def self.find_receiver_metamethod!(receiver, method, signal = nil)
+          if signal.nil?
+            signature = "anonymous()"
+            signal = QtCore::Private::MetaMethod.new(signature, :signal, :ruby)
+          end
+
+          name = QtCore::Private::MetaMethod.normalized_name(method.to_s)
+          compatible_methods = signal.parameters.count.downto(0).map do |n|
+            QtCore::Private::MetaMethod.normalized_signature(name, signal.parameters[0...n])
+          end
+
+          mo = receiver.class._rubyqt6_metaobject
+          until mo.nil?
+            mo.metamethods.each { |meth| return meth if compatible_methods.include?(meth.signature) }
+            mo.metamethods.each { |meth| return meth if name == meth.name } if mo.ruby?
+            mo = mo.super_class
+          end
+
+          qlass = receiver.class.name.split("::").last
+          raise "No compatible metamethod: #{qlass}##{name}"
+        end
+
+        def initialize(qlass)
+          @qlass = qlass
+          @qlass_underlying = @qlass.name.start_with?("RubyQt6::") ? :libQt6 : :ruby
+          @classinfo = {}
+          @metamethods = []
+        end
+
+        def add_classinfo(name, value)
+          @classinfo[name] = value
+        end
+        alias_method :classinfo, :add_classinfo
+
+        def add_signal(signature)
+          @metamethods << QtCore::Private::MetaMethod.new(signature, :signal, @qlass_underlying)
+        end
+        alias_method :signal, :add_signal
+
+        def add_slot(signature)
+          @metamethods << QtCore::Private::MetaMethod.new(signature, :slot, @qlass_underlying)
+        end
+        alias_method :slot, :add_slot
+
+        def class_name
+          @qlass.name
+        end
+
+        def super_class
+          return nil if @qlass == QtCore::QObject
+          @qlass.superclass._rubyqt6_metaobject
+        end
+
+        def ruby?
+          @qlass_underlying == :ruby
+        end
+
+        def to_qmetaobject
+          return @qlass._static_meta_object unless ruby?
+
+          builder = QtCore::QMetaObjectBuilder.new
+          builder.set_class_name(@qlass.name)
+          builder.set_super_class(@qlass.superclass._qmetaobject)
+          @classinfo.each { |name, value| builder.add_class_info(name, value) }
+          @metamethods.each { |meth| _to_qmetaobject_method(builder, meth) }
+          builder.to_meta_object
+        end
+
+        private
+
+        def _to_qmetaobject_method(builder, meth)
+          case meth.type
+          when :signal then _to_qmetaobject_method_signal(builder, meth)
+          when :slot then _to_qmetaobject_method_slot(builder, meth)
+          else raise "Unknown metamethod type: #{meth.type}"
+          end
+        end
+
+        def _to_qmetaobject_method_signal(builder, meth)
+          _methbuilder = builder.add_signal(meth.qsignature[1..])
+        end
+
+        def _to_qmetaobject_method_slot(builder, meth)
+          methbuilder = builder.add_slot(meth.qsignature[1..])
+          methbuilder.set_return_type(meth.return_type) unless meth.return_type.nil?
+        end
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/private/signal.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    module Private
+      class Signal
+        def initialize(sender, metamethod)
+          @sender = sender
+          @metamethod = metamethod
+        end
+
+        def connect(receiver, metamethod)
+          QtCore::Private::SignalManager.connect(@sender, @metamethod, receiver, metamethod)
+        end
+
+        def disconnect(receiver, metamethod)
+          QtCore::Private::SignalManager.disconnect(@sender, @metamethod, receiver, metamethod)
+        end
+
+        def emit(*args)
+          QtCore::Private::SignalManager.emit(@sender, @metamethod, *args)
+        end
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/private/signalmanager.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    module Private
+      class SignalManager
+        def self.connect(sender, signal, receiver, metamethod)
+          metamethod = QtCore::Private::MetaObject.find_receiver_metamethod!(receiver, metamethod, signal)
+          QtCore::QObject._connect(sender, signal.qsignature, receiver, metamethod.qsignature)
+        end
+
+        def self.disconnect(sender, signal, receiver, metamethod)
+          metamethod = QtCore::Private::MetaObject.find_receiver_metamethod!(receiver, metamethod, signal)
+          QtCore::QObject._disconnect(sender, signal.qsignature, receiver, metamethod.qsignature)
+        end
+
+        def self.emit(sender, signal, *args)
+          qmo = sender.class._qmetaobject
+          qmetamethod = qmo.method(qmo.index_of_signal(signal.qsignature[1..]))
+
+          raise "Too many arguments" if qmetamethod.parameter_count < args.count
+          raise "Not enough arguments" if qmetamethod.parameter_count > args.count
+          args = args.map.with_index { |arg, i| QtCore::QVariant.new(arg, qmetamethod.parameter_meta_type(i)) }
+
+          QtCore::QObject._emit(sender, qmetamethod, args)
+        end
+      end
+    end
+  end
+end