qt 0.1.4 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b476ba2b95707fc32d1995f8ae8dfc5c8068ab46020e00ea5442b1fb42dd3220
-  data.tar.gz: 2ffb03be131be2c47d5d89f1094600d6e52fdb6891ffaabc40a3d8d7f6356c31
+  metadata.gz: be7294fb17e8d0cd4eeb66cc86fe6ee91940a95d5a6f3afaf9dfa44fb54445ba
+  data.tar.gz: 20683a100daf8ca9299a2227ae2605acbde2393e2444d020625c058cbc76993c
 SHA512:
-  metadata.gz: 710c7df3d9c1950c14d35762a9223eb64cb4184573e0456fd864f5dd139f35224d03b144d0d121f465221e107e11a7c22e3053ee0b5508db72fe8e803ac3fc0c
-  data.tar.gz: b8424801d5f61607f02ad9fb48cc5e6941f4dc811a38c4dbb5439d2e9f5dc561ed1ed814ec910d9ae81e49d84bf47fd40957ecfee07bb951900c80567ba49789
+  metadata.gz: 151a6423964153f8e5f54cba0cc7c54d1ff6b4a7fbd10b003d2a19f6263831493d18ed6fbaeabf88d5791d3e3326e356ba50e0d5332e212c75341bf6ea3c2f50
+  data.tar.gz: 9e7542fc4bc481b7c3110f4b55aa4b33dd327babbe4aaad3dc4078ce2bd404a97a90022f1e49d97bd3ae05cb805e4db8fd0aef13e368974505dc361d29edfdd9

data/ext/qt_ruby_bridge/qt_ruby_runtime.hpp

@@ -3,7 +3,7 @@
 #include <QApplication>
 
 namespace QtRubyRuntime {
-using EventCallback = void (*)(void*, int, int, int, int, int);
+using EventCallback = int (*)(void*, int, const char*);
 using SignalCallback = void (*)(void*, int, const char*);
 
 // Creates/owns the singleton QApplication used by the Ruby runtime bridge.

data/ext/qt_ruby_bridge/runtime_events.cpp

@@ -1,15 +1,11 @@
 #include "qt_ruby_runtime.hpp"
 
 #include <QApplication>
+#include <QByteArray>
 #include <QCoreApplication>
 #include <QEvent>
 #include <QEventLoop>
-#include <QKeyEvent>
-#include <QMouseEvent>
 #include <QObject>
-#include <QPoint>
-#include <QResizeEvent>
-#include <QByteArray>
 #include <QWidget>
 #include <cstdio>
 #include <cstdlib>
@@ -17,7 +13,13 @@
 #include <unordered_map>
 #include <unordered_set>
 
+#include "../../build/generated/event_payloads.inc"
+
 namespace QtRubyRuntime {
+constexpr int kEventCallbackIgnore = 0;
+constexpr int kEventCallbackContinue = 1;
+constexpr int kEventCallbackConsume = 2;
+
 EventCallback& event_callback_ref() {
   static EventCallback callback = nullptr;
   return callback;
@@ -117,6 +119,8 @@ const char* event_name(int et) {
       return "Leave";
     case QEvent::Resize:
       return "Resize";
+    case QEvent::Wheel:
+      return "Wheel";
     default:
       return "Other";
   }
@@ -161,6 +165,7 @@ bool supports_ancestor_dispatch(int event_type) {
     case QEvent::FocusOut:
     case QEvent::Enter:
     case QEvent::Leave:
+    case QEvent::Wheel:
       return true;
     default:
       return false;
@@ -219,46 +224,16 @@ class EventFilter : public QObject {
       return QObject::eventFilter(watched, event);
     }
 
-    int a = 0;
-    int b = 0;
-    int c = 0;
-    int d = 0;
-
-    switch (event->type()) {
-      case QEvent::MouseButtonPress:
-      case QEvent::MouseButtonRelease:
-      case QEvent::MouseMove: {
-        auto* mouse_event = static_cast<QMouseEvent*>(event);
-        const QPoint p = mouse_event->position().toPoint();
-        a = p.x();
-        b = p.y();
-        c = static_cast<int>(mouse_event->button());
-        d = static_cast<int>(mouse_event->buttons());
-        break;
-      }
-      case QEvent::KeyPress:
-      case QEvent::KeyRelease: {
-        auto* key_event = static_cast<QKeyEvent*>(event);
-        a = key_event->key();
-        b = static_cast<int>(key_event->modifiers());
-        c = key_event->isAutoRepeat() ? 1 : 0;
-        d = key_event->count();
-        break;
-      }
-      case QEvent::Resize: {
-        auto* resize_event = static_cast<QResizeEvent*>(event);
-        a = resize_event->size().width();
-        b = resize_event->size().height();
-        c = resize_event->oldSize().width();
-        d = resize_event->oldSize().height();
-        break;
-      }
-      default:
-        break;
-    }
-
+    const QByteArray payload_json = QtRubyGeneratedEventPayloads::serialize_event_payload(et, event);
     log_event_dispatch(watched, dispatch_target, et, event->isAccepted(), "dispatch");
-    event_callback_ref()(dispatch_target, et, a, b, c, d);
+    const int callback_result = event_callback_ref()(dispatch_target, et, payload_json.constData());
+    if (callback_result == kEventCallbackIgnore) {
+      event->ignore();
+    }
+    if (callback_result == kEventCallbackConsume) {
+      event->accept();
+      return true;
+    }
     return QObject::eventFilter(watched, event);
   }
 };

data/ext/qt_ruby_bridge/runtime_signals.cpp

@@ -1,6 +1,7 @@
 #include "qt_ruby_runtime.hpp"
 
 #include <QByteArray>
+#include <QCoreApplication>
 #include <QDateTimeEdit>
 #include <QMetaMethod>
 #include <QObject>
@@ -29,6 +30,11 @@ std::unordered_map<QObject*, SignalHandlersByIndex>& signal_handlers() {
   return handlers;
 }
 
+QObject* signal_callback_context() {
+  static QObject fallback_context;
+  return QCoreApplication::instance() ? static_cast<QObject*>(QCoreApplication::instance()) : &fallback_context;
+}
+
 int resolve_signal_index(QObject* obj, const char* signal_name) {
   if (!obj || !signal_name) {
     return -1;
@@ -122,7 +128,25 @@ int QtRubyRuntime::qobject_connect_signal(void* object_handle, const char* signa
   }
 
   const QMetaMethod signal_method = obj->metaObject()->method(signal_index);
-  auto* mapper = new QSignalMapper(obj);
+  if (signal_method.name() == "destroyed") {
+    QMetaObject::Connection direct_connection =
+        QObject::connect(obj, &QObject::destroyed, signal_callback_context(), [obj, signal_index](QObject*) {
+          if (!signal_callback_ref()) {
+            return;
+          }
+          signal_callback_ref()(obj, signal_index, signal_payload_for(obj, signal_index));
+        });
+
+    if (!direct_connection) {
+      return -4;
+    }
+
+    auto& by_index = signal_handlers()[obj];
+    by_index[signal_index].push_back(SignalHandler{signal_index, direct_connection, {}, nullptr});
+    return signal_index;
+  }
+
+  auto* mapper = new QSignalMapper(QCoreApplication::instance());
   mapper->setMapping(obj, signal_index);
 
   const int map_slot_index = mapper->metaObject()->indexOfSlot("map()");
@@ -146,6 +170,8 @@ int QtRubyRuntime::qobject_connect_signal(void* object_handle, const char* signa
         signal_callback_ref()(obj, mapped_signal_index, signal_payload_for(obj, mapped_signal_index));
       });
 
+  QObject::connect(obj, &QObject::destroyed, mapper, [mapper]() { mapper->deleteLater(); });
+
   if (!mapped_connection) {
     QObject::disconnect(signal_connection);
     mapper->deleteLater();

data/lib/qt/event_runtime.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Qt
   # Event/signal subscription runtime backed by generated native callbacks.
   module EventRuntime
@@ -28,22 +30,30 @@ module Qt
       ensure_signal_callback!
 
       handle = widget_handle(widget) || raise(ArgumentError, 'widget handle is required')
-      per_signal = prepare_signal_registration(handle, signal_name)
+      per_signal = prepare_signal_registration(@signal_handlers ||= {}, handle, signal_name)
       per_signal[:blocks] << block
       true
     end
 
-    def prepare_signal_registration(handle, signal_name)
+    def on_internal_signal(widget, signal_name, &block)
+      raise ArgumentError, 'pass block to on_internal_signal' unless block
+
+      ensure_native_bridge_ready!
+      ensure_signal_callback!
+
+      handle = widget_handle(widget) || raise(ArgumentError, 'widget handle is required')
+      per_signal = prepare_signal_registration(@internal_signal_handlers ||= {}, handle, signal_name)
+      per_signal[:blocks] << block
+      true
+    end
+
+    def prepare_signal_registration(signal_store, handle, signal_name)
       signal_key = signal_name.to_s
       raise ArgumentError, 'signal name is required' if signal_key.empty?
 
-      @signal_handlers ||= {}
-      per_signal = ((@signal_handlers[handle.address] ||= {})[signal_key] ||= { index: nil, blocks: [] })
+      per_signal = ((signal_store[handle.address] ||= {})[signal_key] ||= { index: nil, blocks: [] })
       if per_signal[:index].nil?
-        index = Qt::Native.qobject_connect_signal(handle, signal_key)
-        raise ArgumentError, "failed to connect signal #{signal_key.inspect} (code=#{index})" if index.negative?
-
-        per_signal[:index] = index
+        per_signal[:index] = acquire_signal_registration(handle, signal_key)
       end
       per_signal
     end
@@ -57,9 +67,14 @@ module Qt
       return false if per_widget.nil?
 
       signal_key = signal_name&.to_s
-      per_widget.delete(signal_key) if signal_key
-      per_widget.clear unless signal_key
-      Qt::Native.qobject_disconnect_signal(handle, signal_key)
+      if signal_key
+        per_widget.delete(signal_key)
+        release_signal_registration(handle, signal_key)
+      else
+        per_widget.keys.each { |registered_signal| release_signal_registration(handle, registered_signal) }
+        per_widget.clear
+      end
+      @signal_handlers.delete(handle.address) if per_widget.empty?
       true
     end
 
@@ -77,13 +92,7 @@ module Qt
 
     def event_type_for(event_name)
       key = event_name.to_sym
-      map = {
-        mouse_button_press: Qt::EventMouseButtonPress, mouse_button_release: Qt::EventMouseButtonRelease,
-        mouse_move: Qt::EventMouseMove, key_press: Qt::EventKeyPress, key_release: Qt::EventKeyRelease,
-        focus_in: Qt::EventFocusIn, focus_out: Qt::EventFocusOut, enter: Qt::EventEnter,
-        leave: Qt::EventLeave, resize: Qt::EventResize
-      }
-      event_type = map[key]
+      event_type = Qt::GENERATED_EVENT_TYPES[key]
       raise ArgumentError, "unknown event: #{event_name.inspect}" unless event_type
 
       event_type
@@ -93,10 +102,9 @@ module Qt
       return if @event_callback
 
       @event_callback = FFI::Function.new(
-        :void, %i[pointer int int int int int]
-      ) do |object_handle, event_type, *args|
-        a, b, c, d = args
-        payload = { type: event_type, a: a, b: b, c: c, d: d }
+        :int, %i[pointer int string]
+      ) do |object_handle, event_type, payload_json|
+        payload = decode_event_payload(event_type, payload_json)
         EventRuntimeDispatch.dispatch_event(@event_handlers, object_handle, event_type, payload)
       end
 
@@ -108,7 +116,9 @@ module Qt
 
       @signal_callback = FFI::Function.new(:void, %i[pointer int string]) do |object_handle, signal_index, payload|
         normalized_payload = payload.nil? ? nil : Qt::StringCodec.from_qt_text(payload)
-        EventRuntimeDispatch.dispatch_signal(@signal_handlers, object_handle, signal_index, normalized_payload)
+        EventRuntimeDispatch.dispatch_signal(
+          @internal_signal_handlers, @signal_handlers, object_handle, signal_index, normalized_payload
+        )
       end
 
       Qt::Native.set_signal_callback(@signal_callback)
@@ -120,6 +130,17 @@ module Qt
       widget.respond_to?(:handle) ? widget.handle : widget
     end
 
+    def decode_event_payload(event_type, payload_json)
+      payload =
+        if payload_json.nil? || payload_json.empty?
+          {}
+        else
+          JSON.parse(Qt::StringCodec.from_qt_text(payload_json), symbolize_names: true)
+        end
+      payload[:type] ||= event_type
+      payload
+    end
+
     def ensure_native_bridge_ready!
       Qt::Native.ensure_loaded!
       Qt::Native.define_bridge_wrappers!
@@ -135,5 +156,42 @@ module Qt
         @event_handlers.delete(handle.address)
       end
     end
+
+    def acquire_signal_registration(handle, signal_key)
+      @signal_registrations ||= {}
+      per_widget = (@signal_registrations[handle.address] ||= {})
+      registration = (per_widget[signal_key] ||= { index: nil, refcount: 0 })
+      if registration[:index].nil?
+        index = Qt::Native.qobject_connect_signal(handle, signal_key)
+        raise ArgumentError, "failed to connect signal #{signal_key.inspect} (code=#{index})" if index.negative?
+
+        registration[:index] = index
+      end
+      registration[:refcount] += 1
+      registration[:index]
+    end
+
+    def release_signal_registration(handle, signal_key)
+      return if @signal_registrations.nil?
+
+      per_widget = @signal_registrations[handle.address]
+      return if per_widget.nil?
+
+      registration = per_widget[signal_key]
+      return if registration.nil?
+
+      registration[:refcount] -= 1
+      return if registration[:refcount].positive?
+
+      Qt::Native.qobject_disconnect_signal(handle, signal_key)
+      per_widget.delete(signal_key)
+      @signal_registrations.delete(handle.address) if per_widget.empty?
+    end
+
+    def clear_signal_registrations_for_address(address)
+      @signal_handlers&.delete(address)
+      @internal_signal_handlers&.delete(address)
+      @signal_registrations&.delete(address)
+    end
   end
 end

data/lib/qt/event_runtime_dispatch.rb

@@ -4,22 +4,37 @@
 module Qt
   # Dispatch helpers for event/signal callbacks from the native bridge.
   module EventRuntimeDispatch
+    EVENT_RESULT_IGNORE = 0
+    EVENT_RESULT_CONTINUE = 1
+    EVENT_RESULT_CONSUME = 2
+
     module_function
 
     def dispatch_event(event_handlers, object_handle, event_type, payload)
-      return unless object_handle && event_handlers
+      return EVENT_RESULT_CONTINUE unless object_handle && event_handlers
 
       per_widget = event_handlers[object_handle.address]
-      return unless per_widget
+      return EVENT_RESULT_CONTINUE unless per_widget
 
       handlers = per_widget[event_type]
-      return unless handlers && !handlers.empty?
+      return EVENT_RESULT_CONTINUE unless handlers && !handlers.empty?
+
+      results = handlers.map { |handler| handler.call(payload) }
+      return EVENT_RESULT_CONSUME if results.any? { |result| result == true || result == :consume }
+      return EVENT_RESULT_IGNORE if results.any? { |result| result == false || result == :ignore }
+
+      EVENT_RESULT_CONTINUE
+    end
+
+    def dispatch_signal(internal_signal_handlers, signal_handlers, object_handle, signal_index, payload)
+      return unless object_handle
 
-      handlers.each { |handler| handler.call(payload) }
+      dispatch_signal_store(signal_handlers, object_handle, signal_index, payload)
+      dispatch_signal_store(internal_signal_handlers, object_handle, signal_index, payload)
     end
 
-    def dispatch_signal(signal_handlers, object_handle, signal_index, payload)
-      return unless object_handle && signal_handlers
+    def dispatch_signal_store(signal_handlers, object_handle, signal_index, payload)
+      return unless signal_handlers
 
       per_widget = signal_handlers[object_handle.address]
       return unless per_widget
@@ -28,7 +43,7 @@ module Qt
         next unless entry[:index] == signal_index
 
         typed_payload = Qt::DateTimeCodec.decode_for_signal(signal_name, payload)
-        entry[:blocks].each { |handler| handler.call(typed_payload) }
+        entry[:blocks].dup.each { |handler| handler.call(typed_payload) }
       end
     end
   end

data/lib/qt/generated_setter_aliases_runtime.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Qt
+  module GeneratedSetterAliasesRuntime
+    module_function
+
+    def apply!(qt_module)
+      qt_module.constants(false).each do |const_name|
+        klass = qt_module.const_get(const_name, false)
+        next unless klass.is_a?(Class)
+
+        apply_instance_aliases!(klass)
+        apply_singleton_aliases!(klass)
+      end
+    end
+
+    def apply_instance_aliases!(klass)
+      apply_aliases_to_target!(klass, klass, :QT_API_SETTER_ALIASES)
+    end
+
+    def apply_singleton_aliases!(klass)
+      apply_aliases_to_target!(klass.singleton_class, klass, :QT_API_SINGLETON_SETTER_ALIASES)
+    end
+
+    def apply_aliases_to_target!(target, owner, constant_name)
+      return unless owner.const_defined?(constant_name, false)
+
+      owner.const_get(constant_name, false).each do |alias_name, setter_name|
+        next if target.method_defined?(alias_name) || target.private_method_defined?(alias_name)
+
+        target.send(:define_method, alias_name) do |value|
+          public_send(setter_name, value)
+        end
+      end
+    end
+  end
+end

data/lib/qt/generated_singleton_forwarders_runtime.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Qt
+  module GeneratedSingletonForwardersRuntime
+    module_function
+
+    def apply!(qt_module)
+      qt_module.constants(false).each do |const_name|
+        klass = qt_module.const_get(const_name, false)
+        next unless klass.is_a?(Class)
+        next unless klass.const_defined?(:QT_API_SINGLETON_FORWARDERS, false)
+
+        klass.const_get(:QT_API_SINGLETON_FORWARDERS, false).each do |method_name|
+          next if klass.instance_methods(false).include?(method_name.to_sym)
+          next if klass.private_instance_methods(false).include?(method_name.to_sym)
+
+          klass.send(:define_method, method_name) do |*args, &block|
+            self.class.public_send(method_name, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qt/object_list_codec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Qt
+  # Decodes QObjectList bridge payloads into canonical Ruby wrappers.
+  module ObjectListCodec
+    module_function
+
+    def decode(payload, expected_qt_class = 'QObject')
+      raw = Qt::StringCodec.from_qt_text(payload.to_s)
+      return [] if raw.empty?
+
+      JSON.parse(raw).filter_map do |address|
+        next if address.nil? || address.to_s.empty?
+
+        Qt::ObjectWrapper.wrap(FFI::Pointer.new(Integer(address, 10)), expected_qt_class)
+      end
+    rescue JSON::ParserError, ArgumentError
+      []
+    end
+  end
+end

data/lib/qt/object_wrapper.rb

@@ -5,14 +5,24 @@ module Qt
   module ObjectWrapper
     module_function
 
+    module ConstructorCacheHook
+      def initialize(*args, &block)
+        super
+        Qt::ObjectWrapper.register_wrapper(self)
+      end
+    end
+
     def wrap(pointer, expected_qt_class = nil)
       return nil if null_pointer?(pointer)
       return pointer if pointer.respond_to?(:handle)
 
+      cached = cached_wrapper_for(pointer)
+      return cached if cached
+
       klass = resolve_wrapper_class(pointer, expected_qt_class) || fallback_wrapper_class(expected_qt_class)
       return pointer unless klass
 
-      instantiate_wrapper(klass, pointer)
+      register_wrapper(instantiate_wrapper(klass, pointer))
     end
 
     def null_pointer?(pointer)
@@ -26,9 +36,10 @@ module Qt
     end
 
     def candidate_wrapper_classes(expected_qt_class)
+      normalized_qt_class = normalize_expected_qt_class(expected_qt_class)
       @candidate_wrapper_classes ||= {}
-      @candidate_wrapper_classes[expected_qt_class] ||= begin
-        base = fallback_wrapper_class(expected_qt_class)
+      @candidate_wrapper_classes[normalized_qt_class] ||= begin
+        base = fallback_wrapper_class(normalized_qt_class)
         wrappers = qobject_wrapper_classes
         wrappers = wrappers.select { |klass| klass <= base } if base
         wrappers.sort_by { |klass| -inheritance_depth(klass) }
@@ -47,23 +58,95 @@ module Qt
     end
 
     def fallback_wrapper_class(expected_qt_class)
-      return nil if expected_qt_class.nil? || !Qt.const_defined?(expected_qt_class, false)
+      normalized_qt_class = normalize_expected_qt_class(expected_qt_class)
+      return nil unless normalized_qt_class
+      return nil unless Qt.const_defined?(normalized_qt_class, false)
 
-      klass = Qt.const_get(expected_qt_class, false)
+      klass = Qt.const_get(normalized_qt_class, false)
       return nil unless klass.is_a?(Class)
       return nil unless klass.const_defined?(:QT_CLASS, false)
       return nil unless klass <= Qt::QObject
 
       klass
+    rescue NameError
+      nil
     end
 
     def instantiate_wrapper(klass, pointer)
       wrapped = klass.allocate
       wrapped.instance_variable_set(:@handle, pointer)
-      wrapped.init_children_tracking! if wrapped.respond_to?(:init_children_tracking!, true)
       wrapped
     end
 
+    def cached_wrapper_for(pointer)
+      wrapper_cache[pointer.address]
+    end
+
+    def register_wrapper(wrapper)
+      return wrapper unless wrapper.respond_to?(:handle)
+
+      pointer = wrapper.handle
+      return wrapper if null_pointer?(pointer)
+
+      cached = cached_wrapper_for(pointer)
+      return cached if cached
+
+      cache_wrapper(wrapper)
+    end
+
+    def cache_wrapper(wrapper)
+      pointer = wrapper.handle
+      wrapper_cache[pointer.address] = wrapper
+      ensure_destroy_hook(wrapper, pointer)
+      wrapper
+    end
+
+    def invalidate_cached_wrapper(pointer_or_address, expected_wrapper = nil)
+      address = pointer_or_address.is_a?(Integer) ? pointer_or_address : pointer_or_address.address
+      cached = wrapper_cache[address]
+      return unless cached
+      return if expected_wrapper && !cached.equal?(expected_wrapper)
+
+      wrapper_cache.delete(address)
+    end
+
+    def reset_cache!
+      @wrapper_cache = {}
+      @destroy_hook_addresses = {}
+    end
+
+    def install_constructor_cache_hooks!
+      qobject_wrapper_classes.each do |klass|
+        next if klass.instance_variable_defined?(:@__qt_object_wrapper_constructor_hook_installed)
+
+        klass.prepend(ConstructorCacheHook)
+        klass.instance_variable_set(:@__qt_object_wrapper_constructor_hook_installed, true)
+      end
+    end
+
+    def wrapper_cache
+      @wrapper_cache ||= {}
+    end
+
+    def destroy_hook_addresses
+      @destroy_hook_addresses ||= {}
+    end
+
+    def ensure_destroy_hook(wrapper, pointer)
+      address = pointer.address
+      return if destroy_hook_addresses[address]
+
+      destroy_hook_addresses[address] = true
+      Qt::EventRuntime.on_internal_signal(pointer, 'destroyed()') do |_payload|
+        destroy_hook_addresses.delete(address)
+        Qt::EventRuntime.clear_signal_registrations_for_address(address)
+        invalidate_cached_wrapper(address, wrapper)
+      end
+    rescue StandardError
+      destroy_hook_addresses.delete(address)
+      raise
+    end
+
     def inheritance_depth(klass)
       depth = 0
       current = klass
@@ -73,5 +156,17 @@ module Qt
       end
       depth
     end
+
+    def normalize_expected_qt_class(expected_qt_class)
+      return nil if expected_qt_class.nil?
+
+      value = expected_qt_class.to_s.strip
+      return nil if value.empty?
+
+      value = value.delete_prefix('Qt::')
+      return nil unless value.match?(/\A[A-Z]\w*\z/)
+
+      value
+    end
   end
 end

data/lib/qt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Qt
-  VERSION = '0.1.4'
+  VERSION = '0.1.7'
 end

data/lib/qt.rb

@@ -8,8 +8,10 @@ GENERATED_DIR = File.join(ROOT, 'build', 'generated')
 GENERATED_WIDGETS = File.join(GENERATED_DIR, 'widgets.rb')
 GENERATED_API = File.join(GENERATED_DIR, 'bridge_api.rb')
 GENERATED_CONSTANTS = File.join(GENERATED_DIR, 'constants.rb')
+GENERATED_EVENT_PAYLOADS = File.join(GENERATED_DIR, 'event_payloads.rb')
 
-unless File.exist?(GENERATED_WIDGETS) && File.exist?(GENERATED_API) && File.exist?(GENERATED_CONSTANTS)
+unless File.exist?(GENERATED_WIDGETS) && File.exist?(GENERATED_API) && File.exist?(GENERATED_CONSTANTS) &&
+       File.exist?(GENERATED_EVENT_PAYLOADS)
   ok = system(RbConfig.ruby, GENERATOR)
   raise 'Failed to generate Qt Ruby bindings. Run: bundle exec rake compile' unless ok
 end
@@ -20,17 +22,23 @@ require_relative 'qt/constants'
 require_relative 'qt/string_codec'
 require_relative 'qt/date_time_codec'
 require_relative 'qt/key_sequence_codec'
+require_relative 'qt/object_list_codec'
 require_relative 'qt/variant_codec'
 require_relative 'qt/inspectable'
-require_relative 'qt/children_tracking'
 require_relative 'qt/object_wrapper'
 require_relative 'qt/application_lifecycle'
 require_relative 'qt/bridge'
 require_relative 'qt/native'
+require_relative 'qt/generated_setter_aliases_runtime'
+require_relative 'qt/generated_singleton_forwarders_runtime'
 require_relative 'qt/event_runtime_dispatch'
 require_relative 'qt/event_runtime_qobject_methods'
 require_relative 'qt/event_runtime'
+require GENERATED_EVENT_PAYLOADS
 require GENERATED_WIDGETS
+Qt::GeneratedSetterAliasesRuntime.apply!(Qt)
+Qt::GeneratedSingletonForwardersRuntime.apply!(Qt)
+Qt::ObjectWrapper.install_constructor_cache_hooks!
 require_relative 'qt/shortcut_compat'
 Qt::GeneratedConstantsRuntime.apply_generated_scoped_constants!(Qt)