qt 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58b685a5934b6ab65de8085da77093cf9de7b608a2f047638e6662ece29f4f8a
-  data.tar.gz: 3ce44932b8d818b1068908d73189704bdd4b1e2f54e6d2e462c83d217b81c3f3
+  metadata.gz: 5b47b66563f703c260222b8ac0e38f2bf27e4ee654dd3152181bb8866e93e182
+  data.tar.gz: 797218dab7d7ce473510b05bd500c8151503b0ebc018648c5d82a5e5abb7e8f0
 SHA512:
-  metadata.gz: aac76dc37741b86a72be2b8b5f1d671b3f0e4fc59ad95e2958264c7a9929f3dad7d445e3bded8f46d67bc304296b0610d7f427ca19eebaec99fd41dff4d454cb
-  data.tar.gz: 50d80970f96868a576ac445b84bbf45ea002bf8c55038b52d3e0c1f2a522d89c6cf2e2120a895b43963cc912900ab63a3520be8d91278d3a8f5a6ec08e364569
+  metadata.gz: 37e94ba0242411ddd9f46d6858f397f53e2d2d62e38ba7ccba9a15fc517f86291b015d82dd359dfe0eb5ce12a011ebeb379d95a23c607c1be299883d5c24ed2a
+  data.tar.gz: 5fc3cc069da9615f8efb690d2888f5ec7f5c02422885e070331b4e271381405a082993c705d100c9e30b6ceb5661471701769c81e5ff6ff072024fe34c7b9c15

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

@@ -30,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
@@ -59,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
 
@@ -103,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)
@@ -141,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

@@ -26,8 +26,15 @@ module Qt
       EVENT_RESULT_CONTINUE
     end
 
-    def dispatch_signal(signal_handlers, object_handle, signal_index, payload)
-      return unless object_handle && signal_handlers
+    def dispatch_signal(internal_signal_handlers, signal_handlers, object_handle, signal_index, payload)
+      return unless object_handle
+
+      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_store(signal_handlers, object_handle, signal_index, payload)
+      return unless signal_handlers
 
       per_widget = signal_handlers[object_handle.address]
       return unless per_widget
@@ -36,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)
+      return wrapper unless qobject_wrapper?(wrapper.class)
+
+      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,21 @@ module Qt
       end
       depth
     end
+
+    def qobject_wrapper?(klass)
+      klass.is_a?(Class) && klass <= Qt::QObject
+    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.6'
+  VERSION = '0.1.8'
 end

data/lib/qt.rb

@@ -22,18 +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)
 

data/scripts/generate_bridge/auto_methods.rb

@@ -52,6 +52,7 @@ def map_cpp_arg_type(type_name, qt_class: nil, int_cast_types: nil)
   return { ffi: :string, cast: :qdate_from_utf8 } if type == 'QDate'
   return { ffi: :string, cast: :qtime_from_utf8 } if type == 'QTime'
   return { ffi: :string, cast: :qkeysequence_from_utf8 } if type == 'QKeySequence'
+  return { ffi: :int, cast: :qcursor_shape } if type == 'QCursor'
   return { ffi: :pointer, cast: :qicon_ref } if type == 'QIcon'
   return { ffi: :string, cast: :qany_string_view } if type == 'QAnyStringView'
   return { ffi: :string, cast: :qvariant_from_utf8 } if type == 'QVariant'
@@ -81,6 +82,7 @@ def map_scalar_cpp_return_type(type)
   return { ffi_return: :int } if type == 'int'
   return { ffi_return: :bool } if type == 'bool'
   return { ffi_return: :string, return_cast: :qstring_to_utf8 } if type == 'QString'
+  return { ffi_return: :string, return_cast: :qobject_list_to_wrapped_array, object_list_class: 'QObject' } if type == 'QObjectList'
   return { ffi_return: :string, return_cast: :qdatetime_to_utf8 } if type == 'QDateTime'
   return { ffi_return: :string, return_cast: :qdate_to_utf8 } if type == 'QDate'
   return { ffi_return: :string, return_cast: :qtime_to_utf8 } if type == 'QTime'
@@ -94,7 +96,7 @@ def map_pointer_cpp_return_type(type, ast: nil)
 
   info = { ffi_return: :pointer }
   base_type = type.sub(/\s*\*\z/, '').strip
-  if ast && class_inherits?(ast, base_type, 'QObject')
+  if ast && ast_class_index(ast)[:methods_by_class].key?(base_type)
     info[:pointer_class] = base_type
   end
 

data/scripts/generate_bridge/cpp_method_return_emitter.rb

@@ -11,6 +11,7 @@ class CppMethodReturnEmitter
   def emit
     return emit_void if method[:ffi_return] == :void
     return emit_qstring if qstring_return?
+    return emit_qobject_list if qobject_list_return?
     return emit_qdatetime if qdatetime_return?
     return emit_qdate if qdate_return?
     return emit_qtime if qtime_return?
@@ -32,6 +33,10 @@ class CppMethodReturnEmitter
     method[:ffi_return] == :string && method[:return_cast] == :qvariant_to_utf8
   end
 
+  def qobject_list_return?
+    method[:ffi_return] == :string && method[:return_cast] == :qobject_list_to_wrapped_array
+  end
+
   def qdatetime_return?
     method[:ffi_return] == :string && method[:return_cast] == :qdatetime_to_utf8
   end
@@ -62,6 +67,13 @@ class CppMethodReturnEmitter
     lines << '  return utf8.constData();'
   end
 
+  def emit_qobject_list
+    lines << "  const QObjectList value = #{invocation};"
+    lines << '  thread_local QByteArray utf8;'
+    lines << '  utf8 = qobject_list_to_bridge_string(value).toUtf8();'
+    lines << '  return utf8.constData();'
+  end
+
   def emit_qdatetime
     lines << "  const QDateTime value = #{invocation};"
     lines << '  thread_local QByteArray utf8;'

data/scripts/generate_bridge/ffi_api.rb

@@ -19,6 +19,8 @@ def all_ffi_functions(specs, free_function_specs:)
 end
 
 def append_constructor_ffi_function(fns, spec)
+  return if spec[:constructor][:mode] == :wrap_only
+
   ctor_args = constructor_ffi_args(spec)
   fns << { name: ctor_function_name(spec), ffi_return: :pointer, args: ctor_args }
 end

data/scripts/generate_bridge/spec_discovery.rb

@@ -160,7 +160,7 @@ def related_value_class_candidate?(ast, qt_class, all_classes, template_classes)
   return false if abstract_class?(ast, qt_class)
   return false if class_inherits?(ast, qt_class, 'QObject')
 
-  constructor_usable_for_codegen?(ast, qt_class)
+  true
 end
 
 def related_qt_type_names(ast, qt_class)
@@ -178,11 +178,12 @@ end
 
 def append_related_qt_types_from_decl(out, parsed, method_name)
   candidates = []
-  candidates << normalized_cpp_type_name(parsed[:return_type]).to_s if parsed[:return_type]
-  parsed[:params].each { |param| candidates << normalized_cpp_type_name(param[:type]).to_s }
-  candidates.each do |candidate|
+  candidates << [related_qt_type_name(parsed[:return_type]), parsed[:return_type].to_s] if parsed[:return_type]
+  parsed[:params].each { |param| candidates << [related_qt_type_name(param[:type]), param[:type].to_s] }
+  candidates.each do |candidate, raw_type|
     next if candidate.empty? || !candidate.start_with?('Q')
-    next unless related_type_name_matches_method?(candidate, method_name)
+    next unless related_type_name_matches_method?(candidate, method_name) ||
+                (qt_pointer_type?(raw_type) && candidate.end_with?('Item'))
 
     out << candidate
   end
@@ -195,6 +196,14 @@ def related_type_name_matches_method?(qt_type, method_name)
   method_name.to_s.downcase.include?(token)
 end
 
+def qt_pointer_type?(raw_type)
+  raw_type.to_s.strip.end_with?('*')
+end
+
+def related_qt_type_name(raw_type)
+  normalized_cpp_type_name(raw_type).to_s.delete_suffix('*')
+end
+
 def discover_target_qt_classes(ast, scope)
   all_classes = q_class_names(ast)
   template_classes = template_qt_classes(ast)
@@ -220,9 +229,24 @@ def widget_target_qt_class?(ast, qt_class)
 
   class_inherits?(ast, qt_class, 'QWidget') ||
     class_inherits?(ast, qt_class, 'QLayout') ||
+    widget_item_target_qt_class?(ast, qt_class) ||
     qt_class == 'QTableWidgetItem'
 end
 
+def widget_item_target_qt_class?(ast, qt_class)
+  return false unless qt_class.end_with?('Item')
+  return false if class_inherits?(ast, qt_class, 'QObject')
+
+  collect_constructor_decls(ast, qt_class).any? do |decl|
+    parsed = parse_method_signature(decl)
+    next false unless parsed
+
+    parsed[:params].any? do |param|
+      normalized_cpp_type_name(param[:type]).to_s.match?(/\AQ\w*Widget\*\z/)
+    end
+  end
+end
+
 def qobject_target_qt_class?(ast, qt_class)
   return false if qt_class.end_with?('Private')
   return false if qt_class == 'QApplication'
@@ -264,8 +288,10 @@ def build_base_spec_for_qt_class(ast, qt_class)
       parent_constructor_for_type(parent_type, widget_child)
     elsif string_path_cast
       string_path_constructor(string_path_cast)
-    else
+    elsif ctor_decls.any? { |decl| constructor_supports_no_args?(decl) }
       { parent: false }
+    else
+      { parent: false, mode: :wrap_only }
     end
   base_spec_hash(qt_class, parent_ctor)
 end

data/scripts/generate_bridge.rb

@@ -246,6 +246,7 @@ def arg_expr(arg)
   when :qdate_from_utf8 then "qdate_from_bridge_value(#{arg[:name]})"
   when :qtime_from_utf8 then "qtime_from_bridge_value(#{arg[:name]})"
   when :qkeysequence_from_utf8 then "QKeySequence(as_qstring(#{arg[:name]}))"
+  when :qcursor_shape then "QCursor(static_cast<Qt::CursorShape>(#{arg[:name]}))"
   when :qicon_ref then "*static_cast<QIcon*>(#{arg[:name]})"
   when :qany_string_view then "QAnyStringView(as_qstring(#{arg[:name]}))"
   when :qvariant_from_utf8 then "qvariant_from_bridge_value(#{arg[:name]})"
@@ -385,8 +386,10 @@ def generate_cpp_bridge(specs, free_function_specs)
 end
 
 def append_cpp_spec_methods(lines, spec)
-  generate_cpp_constructor(lines, spec)
-  lines << ''
+  unless spec[:constructor][:mode] == :wrap_only
+    generate_cpp_constructor(lines, spec)
+    lines << ''
+  end
   spec[:methods].each do |method|
     generate_cpp_method(lines, spec, method)
     lines << ''
@@ -549,6 +552,14 @@ def cpp_bridge_prelude
       const QByteArray fallback = value.toString().toUtf8().toBase64();
       return QStringLiteral("qtv:str:") + QString::fromUtf8(fallback);
     }
+
+    QString qobject_list_to_bridge_string(const QObjectList& value) {
+      QJsonArray array;
+      for (QObject* object : value) {
+        array.append(QString::number(reinterpret_cast<quintptr>(object)));
+      }
+      return QString::fromUtf8(QJsonDocument(array).toJson(QJsonDocument::Compact));
+    }
     }  // namespace
   CPP
 end
@@ -590,14 +601,19 @@ def ruby_api_metadata(methods)
   ruby_method_names = methods.flat_map do |method|
     ruby_name = ruby_safe_method_name(method[:ruby_name])
     snake = to_snake(ruby_name)
-    snake == ruby_name ? [ruby_name] : [ruby_name, snake]
+    names = snake == ruby_name ? [ruby_name] : [ruby_name, snake]
+    names.concat(setter_alias_method_names(method))
+    names
   end.uniq
   properties = methods.filter_map { |method| method[:property] }.uniq
 
   {
     qt_method_names: qt_method_names,
     ruby_method_names: ruby_method_names,
-    properties: properties
+    properties: properties,
+    setter_aliases: {},
+    singleton_setter_aliases: {},
+    singleton_forwarders: []
   }
 end
 
@@ -606,6 +622,9 @@ def append_ruby_class_api_constants(lines, qt_class:, metadata:, indent:)
   lines << "#{indent}QT_API_QT_METHODS = #{metadata[:qt_method_names].inspect}.freeze"
   lines << "#{indent}QT_API_RUBY_METHODS = #{metadata[:ruby_method_names].map(&:to_sym).inspect}.freeze"
   lines << "#{indent}QT_API_PROPERTIES = #{metadata[:properties].map(&:to_sym).inspect}.freeze"
+  lines << "#{indent}QT_API_SETTER_ALIASES = #{metadata[:setter_aliases].inspect}.freeze"
+  lines << "#{indent}QT_API_SINGLETON_SETTER_ALIASES = #{metadata[:singleton_setter_aliases].inspect}.freeze"
+  lines << "#{indent}QT_API_SINGLETON_FORWARDERS = #{metadata[:singleton_forwarders].inspect}.freeze"
 end
 
 def ruby_method_arguments(method, arg_map, required_arg_count)
@@ -675,6 +694,9 @@ end
 
 def ruby_native_method_body(method, rewritten_native_call)
   return "Qt::StringCodec.from_qt_text(#{rewritten_native_call})" if method[:return_cast] == :qstring_to_utf8
+  if method[:return_cast] == :qobject_list_to_wrapped_array
+    return "Qt::ObjectListCodec.decode(#{rewritten_native_call}, '#{method[:object_list_class]}')"
+  end
   return "Qt::VariantCodec.decode(#{rewritten_native_call})" if method[:return_cast] == :qvariant_to_utf8
   return "Qt::DateTimeCodec.decode_qdatetime(#{rewritten_native_call})" if method[:return_cast] == :qdatetime_to_utf8
   return "Qt::DateTimeCodec.decode_qdate(#{rewritten_native_call})" if method[:return_cast] == :qdate_to_utf8
@@ -694,8 +716,46 @@ def append_ruby_property_writer(lines, method:, indent:)
   lines << "#{indent}alias_method :#{snake_property}=, :#{method[:property]}=" if snake_property != method[:property]
 end
 
+def setter_alias_base_name(method)
+  return nil unless method[:args].length == 1
+  return nil if method[:property]
+
+  return 'cursor' if method[:qt_name] == 'setCursor'
+
+  property_name_from_setter(method[:qt_name] || method[:ruby_name].to_s)
+end
+
+def setter_alias_method_names(method)
+  setter_alias_specs(method).keys
+end
+
+def setter_alias_specs(method)
+  base_name = setter_alias_base_name(method)
+  return {} unless base_name
+
+  ruby_target = ruby_public_method_name(base_name)
+  snake_target = to_snake(ruby_target)
+  setter_method_name = ruby_safe_method_name(method[:ruby_name])
+  aliases = { "#{ruby_target}=" => setter_method_name }
+  aliases["#{snake_target}="] = setter_method_name if snake_target != ruby_target
+  aliases
+end
+
+def qapplication_singleton_forwarder_names(methods, singleton_setter_aliases)
+  method_names = methods.flat_map do |method|
+    ruby_name = ruby_safe_method_name(method[:ruby_name])
+    snake_alias = to_snake(ruby_name)
+    snake_alias == ruby_name ? [ruby_name] : [ruby_name, snake_alias]
+  end
+
+  (method_names + singleton_setter_aliases.keys).uniq
+end
+
 def append_widget_initializer(lines, spec:, widget_root:, indent:)
-  if spec[:constructor][:mode] == :string_path
+  if spec[:constructor][:mode] == :wrap_only
+    append_wrap_only_initializer(lines, spec, indent)
+    return
+  elsif spec[:constructor][:mode] == :string_path
     append_string_path_initializer(lines, spec, indent)
   elsif spec[:constructor][:mode] == :keysequence_parent
     append_keysequence_parent_initializer(lines, spec, widget_root, indent)
@@ -709,10 +769,15 @@ def append_widget_initializer(lines, spec:, widget_root:, indent:)
   lines << "#{indent}end"
 end
 
+def append_wrap_only_initializer(lines, spec, indent)
+  lines << "#{indent}def initialize(*)"
+  lines << "#{indent}  raise NotImplementedError, '#{spec[:ruby_class]} cannot be directly instantiated yet'"
+  lines << "#{indent}end"
+end
+
 def append_parent_widget_initializer(lines, spec, widget_root, indent)
   lines << "#{indent}def initialize(parent = nil)"
   lines << "#{indent}  @handle = Native.#{spec[:prefix]}_new(parent&.handle)"
-  lines << "#{indent}  init_children_tracking!" if widget_root
   append_parent_registration_logic(lines, spec, indent)
 end
 
@@ -733,20 +798,15 @@ def append_keysequence_parent_initializer(lines, spec, widget_root, indent)
   lines << "#{indent}    key = nil"
   lines << "#{indent}  end"
   lines << "#{indent}  @handle = Native.#{spec[:prefix]}_new(Qt::KeySequenceCodec.encode(key), parent&.handle)"
-  lines << "#{indent}  init_children_tracking!" if widget_root
   append_parent_registration_logic(lines, spec, indent)
 end
 
 def append_parent_registration_logic(lines, spec, indent)
   if spec[:ruby_class] == 'QWidget'
-    lines << "#{indent}  if parent"
-    lines << "#{indent}    parent.add_child(self)"
-    lines << "#{indent}  else"
+    lines << "#{indent}  unless parent"
     lines << "#{indent}    app = QApplication.current"
     lines << "#{indent}    app&.register_window(self)"
     lines << "#{indent}  end"
-  elsif spec[:constructor][:register_in_parent]
-    lines << "#{indent}  parent.add_child(self) if parent&.respond_to?(:add_child)"
   end
 end
 
@@ -773,6 +833,13 @@ end
 
 def generate_ruby_qapplication(lines, spec)
   metadata = ruby_api_metadata(spec[:methods])
+  metadata[:singleton_setter_aliases] = Array(spec[:class_methods]).each_with_object({}) do |method, aliases|
+    aliases.merge!(setter_alias_specs(method))
+  end
+  metadata[:singleton_forwarders] = qapplication_singleton_forwarder_names(
+    Array(spec[:class_methods]),
+    metadata[:singleton_setter_aliases]
+  )
 
   append_ruby_qapplication_prelude(lines, spec, metadata)
   append_ruby_qapplication_singleton_accessors(lines)
@@ -826,6 +893,9 @@ end
 
 def qapplication_class_method_body(method, native_call)
   return "        Qt::StringCodec.from_qt_text(#{native_call})" if method[:return_cast] == :qstring_to_utf8
+  if method[:return_cast] == :qobject_list_to_wrapped_array
+    return "        Qt::ObjectListCodec.decode(#{native_call}, '#{method[:object_list_class]}')"
+  end
   return "        Qt::DateTimeCodec.decode_qdatetime(#{native_call})" if method[:return_cast] == :qdatetime_to_utf8
   return "        Qt::DateTimeCodec.decode_qdate(#{native_call})" if method[:return_cast] == :qdate_to_utf8
   return "        Qt::DateTimeCodec.decode_qtime(#{native_call})" if method[:return_cast] == :qtime_to_utf8
@@ -842,9 +912,7 @@ def generate_ruby_widget_class_header(lines, spec, metadata:, super_ruby:, class
   append_ruby_class_api_constants(lines, qt_class: spec[:qt_class], metadata: metadata, indent: '    ')
   lines << ''
   lines << '    attr_reader :handle'
-  lines << '    attr_reader :children' if widget_root
   lines << '    include Inspectable'
-  lines << '    include ChildrenTracking' if widget_root
   lines << '    include EventRuntime::QObjectMethods' if qobject_based
   lines << ''
 end
@@ -883,7 +951,11 @@ end
 def ruby_api_metadata_for_spec(spec, specs_by_qt, super_qt_by_qt)
   inherited_methods = inherited_methods_for_spec(spec, specs_by_qt, super_qt_by_qt)
   all_methods = (inherited_methods + spec[:methods]).uniq { |method| method[:qt_name] }
-  ruby_api_metadata(all_methods)
+  metadata = ruby_api_metadata(all_methods)
+  metadata[:setter_aliases] = all_methods.each_with_object({}) do |method, aliases|
+    aliases.merge!(setter_alias_specs(method))
+  end
+  metadata
 end
 
 def ruby_super_class_for_spec(spec, super_qt_by_qt, qt_to_ruby)
@@ -991,6 +1063,7 @@ def collect_enum_constants_for_scope(ast, target_scope, warnings = [])
     next unless node['kind'] == 'EnumDecl'
     next unless scope == target_scope
 
+    next_value = 0
     Array(node['inner']).each do |entry|
       next unless entry['kind'] == 'EnumConstantDecl'
 
@@ -1000,9 +1073,14 @@ def collect_enum_constants_for_scope(ast, target_scope, warnings = [])
 
       raw_value = ast_extract_first_value(entry)
       value = parse_ast_integer_value(raw_value)
-      next if value.nil?
+      if value.nil?
+        value = next_value
+      else
+        next_value = value
+      end
 
       append_constant_with_conflict_warning(constants, name, value, warnings, target_scope.join('::'))
+      next_value = value + 1
     end
   end
 
@@ -1017,6 +1095,9 @@ def collect_qt_namespace_enum_constants(ast, warnings = [])
 
     append_constant_with_conflict_warning(constants, alias_name, value, warnings, 'Qt::QEventAlias')
   end
+  collect_enum_constants_for_scope(ast, ['QCursor'], warnings).each do |name, value|
+    append_constant_with_conflict_warning(constants, name, value, warnings, 'Qt::QCursorAlias')
+  end
   constants
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qt
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Maksim Veynberg
@@ -50,7 +50,6 @@ files:
 - lib/qt.rb
 - lib/qt/application_lifecycle.rb
 - lib/qt/bridge.rb
-- lib/qt/children_tracking.rb
 - lib/qt/constants.rb
 - lib/qt/date_time_codec.rb
 - lib/qt/errors.rb
@@ -58,9 +57,12 @@ files:
 - lib/qt/event_runtime_dispatch.rb
 - lib/qt/event_runtime_qobject_methods.rb
 - lib/qt/generated_constants_runtime.rb
+- lib/qt/generated_setter_aliases_runtime.rb
+- lib/qt/generated_singleton_forwarders_runtime.rb
 - lib/qt/inspectable.rb
 - lib/qt/key_sequence_codec.rb
 - lib/qt/native.rb
+- lib/qt/object_list_codec.rb
 - lib/qt/object_wrapper.rb
 - lib/qt/shortcut_compat.rb
 - lib/qt/string_codec.rb
@@ -98,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.9
 specification_version: 4
 summary: Ruby bindings for Qt 6.4.2+
 test_files: []

data/lib/qt/children_tracking.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Qt
-  # Child object tracking to mirror Qt parent/child ownership in Ruby.
-  module ChildrenTracking
-    def init_children_tracking!
-      @children = []
-    end
-
-    def add_child(child)
-      @children ||= []
-      @children << child
-    end
-  end
-end