qt 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b47b66563f703c260222b8ac0e38f2bf27e4ee654dd3152181bb8866e93e182
-  data.tar.gz: 797218dab7d7ce473510b05bd500c8151503b0ebc018648c5d82a5e5abb7e8f0
+  metadata.gz: c0e7757f47bb17be90f64d3bcdd28ba17e5e8099a505062a7e7c3dd71aaedf37
+  data.tar.gz: cbf55606a5a16e12cb4ef47b73756a1f3ef3b65c1e500583928a44a4d28b97c4
 SHA512:
-  metadata.gz: 37e94ba0242411ddd9f46d6858f397f53e2d2d62e38ba7ccba9a15fc517f86291b015d82dd359dfe0eb5ce12a011ebeb379d95a23c607c1be299883d5c24ed2a
-  data.tar.gz: 5fc3cc069da9615f8efb690d2888f5ec7f5c02422885e070331b4e271381405a082993c705d100c9e30b6ceb5661471701769c81e5ff6ff072024fe34c7b9c15
+  metadata.gz: 1e5e470938bc069179be121de52a5e2986479a7fa8dec030d743de246fef73812729bc57ea67d4958c076e42e8d23ef703c0931e51544f206352e3ba45a3c463
+  data.tar.gz: bc3d7083a9617ad49b2b139d0948bec69257ad5991be08525de8228e87aa3457bdd9d4d2745b399bf20f0266143428565e3fb5d88e039255687eb90b38c7efe9

data/README.md

@@ -301,6 +301,12 @@ Native event-runtime debug logs:
 QT_RUBY_EVENT_DEBUG=1 ruby your_app.rb
 ```
 
+Object-wrapper fallback debug logs:
+
+```bash
+QT_RUBY_OBJECT_WRAPPER_DEBUG=1 ruby your_app.rb
+```
+
 Optional tuning:
 
 ```bash

data/ext/qt_ruby_bridge/extconf.rb

@@ -6,6 +6,11 @@ require 'fileutils'
 PKG_CONFIG = RbConfig::CONFIG['PKG_CONFIG'] || 'pkg-config'
 QT_PACKAGES = %w[Qt6Core Qt6Gui Qt6Widgets].freeze
 MINIMUM_QT_VERSION = Gem::Version.new('6.4.2')
+ROOT = File.expand_path('../..', __dir__)
+GENERATOR = File.join(ROOT, 'scripts/generate_bridge.rb')
+GENERATED_CPP = File.join(ROOT, 'build/generated/qt_ruby_bridge.cpp')
+GENERATED_EVENT_PAYLOADS = File.join(ROOT, 'build/generated/event_payloads.inc')
+LOCAL_CPP = File.expand_path('qt_ruby_bridge.cpp')
 
 def pkg_config(*)
   system(PKG_CONFIG, *, out: File::NULL, err: File::NULL)
@@ -15,15 +20,27 @@ def pkg_config_capture(*args)
   `#{[PKG_CONFIG, *args].join(' ')}`.strip
 end
 
-abort 'pkg-config is required to build qt-ruby bridge.' unless find_executable(PKG_CONFIG)
+def generated_bridge_inputs_available?
+  (File.exist?(LOCAL_CPP) || File.exist?(GENERATED_CPP)) && File.exist?(GENERATED_EVENT_PAYLOADS)
+end
+
+def generator_env
+  scope = ENV.fetch('QT_RUBY_SCOPE', nil)
+  scope && !scope.empty? ? { 'QT_RUBY_SCOPE' => scope } : {}
+end
+
+def ensure_generated_bridge_inputs!
+  return false if generated_bridge_inputs_available?
 
-generator = File.expand_path('../../scripts/generate_bridge.rb', __dir__)
-abort "Generator script not found: #{generator}" unless File.exist?(generator)
+  abort "Generator script not found: #{GENERATOR}" unless File.exist?(GENERATOR)
+  abort 'Failed to generate Qt bridge files.' unless system(generator_env, RbConfig.ruby, GENERATOR)
+
+  true
+end
+
+abort 'pkg-config is required to build qt-ruby bridge.' unless find_executable(PKG_CONFIG)
 
-generator_env = {}
-scope = ENV.fetch('QT_RUBY_SCOPE', nil)
-generator_env['QT_RUBY_SCOPE'] = scope if scope && !scope.empty?
-abort 'Failed to generate Qt bridge files.' unless system(generator_env, RbConfig.ruby, generator)
+generated_by_extconf = ensure_generated_bridge_inputs!
 
 missing = QT_PACKAGES.reject { |pkg| pkg_config('--exists', pkg) }
 abort "Missing Qt packages: #{missing.join(', ')}" unless missing.empty?
@@ -34,15 +51,16 @@ abort "Qt version #{qt_version} is too old. Require >= #{MINIMUM_QT_VERSION}." i
 
 cflags = pkg_config_capture('--cflags', *QT_PACKAGES)
 libs = pkg_config_capture('--libs', *QT_PACKAGES)
-generated_cpp = if File.exist?('qt_ruby_bridge.cpp')
-                  File.expand_path('qt_ruby_bridge.cpp')
+generated_cpp = if !generated_by_extconf && File.exist?(LOCAL_CPP)
+                  LOCAL_CPP
                 else
-                  File.expand_path('../../build/generated/qt_ruby_bridge.cpp', __dir__)
+                  GENERATED_CPP
                 end
 runtime_hpp = File.expand_path('../../ext/qt_ruby_bridge/qt_ruby_runtime.hpp', __dir__)
 runtime_cpp_files = %w[
   runtime_events.cpp
   runtime_signals.cpp
+  runtime_value_types.cpp
 ].map { |name| File.expand_path("../../ext/qt_ruby_bridge/#{name}", __dir__) }
 
 unless File.exist?(generated_cpp)
@@ -52,8 +70,7 @@ abort "Runtime header not found: #{runtime_hpp}" unless File.exist?(runtime_hpp)
 missing_runtime = runtime_cpp_files.reject { |path| File.exist?(path) }
 abort "Runtime source not found: #{missing_runtime.join(', ')}" unless missing_runtime.empty?
 
-local_cpp = File.expand_path('qt_ruby_bridge.cpp')
-FileUtils.cp(generated_cpp, local_cpp) unless File.exist?(local_cpp) && File.identical?(generated_cpp, local_cpp)
+FileUtils.cp(generated_cpp, LOCAL_CPP) unless File.exist?(LOCAL_CPP) && File.identical?(generated_cpp, LOCAL_CPP)
 runtime_cpp_files.each do |runtime_cpp|
   local_runtime_cpp = File.expand_path(File.basename(runtime_cpp))
   unless File.exist?(local_runtime_cpp) && File.identical?(runtime_cpp, local_runtime_cpp)

data/ext/qt_ruby_bridge/qt_ruby_runtime.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <QApplication>
+#include <QList>
+#include <QVariant>
 
 namespace QtRubyRuntime {
 using EventCallback = int (*)(void*, int, const char*);
@@ -13,6 +15,10 @@ QApplication* qapplication_new(const char* argv0);
 // Returns false when teardown is rejected by runtime safety checks.
 bool qapplication_delete(void* app_handle);
 
+// FFI-safe conversion for public Qt QList<int> API parameters and results.
+QList<int> qint_list_from_variant(const QVariant& value);
+QVariant qvariant_from_qint_list(const QList<int>& value);
+
 void set_event_callback(void* callback_ptr);
 void watch_qobject_event(void* object_handle, int event_type);
 void unwatch_qobject_event(void* object_handle, int event_type);

data/ext/qt_ruby_bridge/runtime_events.cpp

@@ -19,6 +19,7 @@ namespace QtRubyRuntime {
 constexpr int kEventCallbackIgnore = 0;
 constexpr int kEventCallbackContinue = 1;
 constexpr int kEventCallbackConsume = 2;
+constexpr int kEventCallbackReject = 3;
 
 EventCallback& event_callback_ref() {
   static EventCallback callback = nullptr;
@@ -234,6 +235,10 @@ class EventFilter : public QObject {
       event->accept();
       return true;
     }
+    if (callback_result == kEventCallbackReject) {
+      event->ignore();
+      return true;
+    }
     return QObject::eventFilter(watched, event);
   }
 };
@@ -244,10 +249,10 @@ EventFilter* event_filter_instance() {
 }
 
 void ensure_event_filter_installed() {
-  static bool installed = false;
-  if (!installed && qApp) {
+  static QApplication* installed_on = nullptr;
+  if (qApp && installed_on != qApp) {
     qApp->installEventFilter(event_filter_instance());
-    installed = true;
+    installed_on = qApp;
   }
 }
 

data/ext/qt_ruby_bridge/runtime_value_types.cpp

@@ -0,0 +1,22 @@
+#include "qt_ruby_runtime.hpp"
+
+namespace QtRubyRuntime {
+QList<int> qint_list_from_variant(const QVariant& value) {
+  QList<int> result;
+  const QVariantList values = value.toList();
+  result.reserve(values.size());
+  for (const QVariant& entry : values) {
+    result.append(entry.toInt());
+  }
+  return result;
+}
+
+QVariant qvariant_from_qint_list(const QList<int>& value) {
+  QVariantList result;
+  result.reserve(value.size());
+  for (int entry : value) {
+    result.append(entry);
+  }
+  return result;
+}
+}  // namespace QtRubyRuntime

data/lib/qt/event_runtime_dispatch.rb

@@ -7,6 +7,7 @@ module Qt
     EVENT_RESULT_IGNORE = 0
     EVENT_RESULT_CONTINUE = 1
     EVENT_RESULT_CONSUME = 2
+    EVENT_RESULT_REJECT = 3
 
     module_function
 
@@ -20,6 +21,7 @@ module Qt
       return EVENT_RESULT_CONTINUE unless handlers && !handlers.empty?
 
       results = handlers.map { |handler| handler.call(payload) }
+      return EVENT_RESULT_REJECT if results.include?(:reject)
       return EVENT_RESULT_CONSUME if results.any? { |result| result == true || result == :consume }
       return EVENT_RESULT_IGNORE if results.any? { |result| result == false || result == :ignore }
 

data/lib/qt/object_wrapper.rb

@@ -20,7 +20,10 @@ module Qt
       return cached if cached
 
       klass = resolve_wrapper_class(pointer, expected_qt_class) || fallback_wrapper_class(expected_qt_class)
-      return pointer unless klass
+      unless klass
+        warn_unwrapped_pointer(pointer, expected_qt_class)
+        return pointer
+      end
 
       register_wrapper(instantiate_wrapper(klass, pointer))
     end
@@ -113,6 +116,7 @@ module Qt
     def reset_cache!
       @wrapper_cache = {}
       @destroy_hook_addresses = {}
+      @unwrapped_pointer_warning_keys = {}
     end
 
     def install_constructor_cache_hooks!
@@ -132,6 +136,33 @@ module Qt
       @destroy_hook_addresses ||= {}
     end
 
+    def object_wrapper_debug_enabled?
+      ENV['QT_RUBY_OBJECT_WRAPPER_DEBUG'] == '1'
+    end
+
+    def warn_unwrapped_pointer(pointer, expected_qt_class)
+      return unless object_wrapper_debug_enabled?
+
+      label = warning_qt_class_label(expected_qt_class)
+      return if unwrapped_pointer_warning_keys[label]
+
+      unwrapped_pointer_warning_keys[label] = true
+      warn "[qt-ruby-wrapper] returning raw pointer for #{label}; no generated wrapper class matched " \
+           "address=0x#{pointer.address.to_s(16)}"
+    end
+
+    def warning_qt_class_label(expected_qt_class)
+      normalized = normalize_expected_qt_class(expected_qt_class)
+      return normalized if normalized
+
+      raw = expected_qt_class.to_s.strip
+      raw.empty? ? '(unknown Qt class)' : raw
+    end
+
+    def unwrapped_pointer_warning_keys
+      @unwrapped_pointer_warning_keys ||= {}
+    end
+
     def ensure_destroy_hook(wrapper, pointer)
       address = pointer.address
       return if destroy_hook_addresses[address]

data/lib/qt/value_wrapper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Qt
+  # Owns copied Qt value objects returned through opaque FFI handles.
+  module ValueWrapper
+    module_function
+
+    def wrap(handle, qt_class, delete_method)
+      return nil if handle.nil? || handle.null?
+
+      wrapper = Qt.const_get(qt_class).allocate
+      wrapper.instance_variable_set(:@handle, handle)
+      ObjectSpace.define_finalizer(wrapper, finalizer(delete_method, handle))
+      wrapper
+    end
+
+    def finalizer(delete_method, handle)
+      proc do
+        Qt::Native.public_send(delete_method, handle) if Qt::Native.available?
+      rescue StandardError
+        nil
+      end
+    end
+    private_class_method :finalizer
+  end
+end

data/lib/qt/version.rb

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

data/lib/qt.rb

@@ -24,6 +24,7 @@ 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/value_wrapper'
 require_relative 'qt/inspectable'
 require_relative 'qt/object_wrapper'
 require_relative 'qt/application_lifecycle'

data/scripts/generate_bridge/auto_methods.rb

@@ -38,7 +38,7 @@ def map_cpp_intlike_arg_type(type_name, qt_class, int_cast_types)
   map_qualified_intlike_arg_type(type_name, qt_class, int_cast_types)
 end
 
-def map_cpp_arg_type(type_name, qt_class: nil, int_cast_types: nil)
+def map_cpp_arg_type(type_name, qt_class: nil, int_cast_types: nil, ast: nil)
   raw = type_name.to_s.strip
   return nil if raw.end_with?('&') && !raw.start_with?('const ')
 
@@ -46,7 +46,7 @@ def map_cpp_arg_type(type_name, qt_class: nil, int_cast_types: nil)
 
   type = raw
   type = type.sub(/\Aconst\s+/, '').sub(/\s*&\z/, '').strip
-  return nil if unsupported_cpp_type?(type)
+  return { ffi: :string, cast: :qint_list_from_variant } if type == 'QList<int>'
   return { ffi: :string, cast: :qstring } if type == 'QString'
   return { ffi: :string, cast: :qdatetime_from_utf8 } if type == 'QDateTime'
   return { ffi: :string, cast: :qdate_from_utf8 } if type == 'QDate'
@@ -58,6 +58,12 @@ def map_cpp_arg_type(type_name, qt_class: nil, int_cast_types: nil)
   return { ffi: :string, cast: :qvariant_from_utf8 } if type == 'QVariant'
   return { ffi: :string } if compact_raw.match?(/\Aconst\s+char\s*\*\z/)
 
+  if ast_qt_value_class?(ast, type)
+    return { ffi: :pointer, cast: :qt_value_ref, value_class: type }
+  end
+
+  return nil if unsupported_cpp_type?(type)
+
   map_cpp_pointer_arg_type(type, qt_class) || map_cpp_intlike_arg_type(type, qt_class, int_cast_types)
 end
 
@@ -70,11 +76,25 @@ end
 
 def map_cpp_return_type(type_name, ast: nil)
   raw = type_name.to_s.strip
+  type = raw.sub(/\Aconst\s+/, '').sub(/\s*&\z/, '').strip
+  return { ffi_return: :string, return_cast: :qint_list_to_variant } if type == 'QList<int>'
   return nil if unsupported_cpp_type?(raw)
   return nil if raw.start_with?('const ') && raw.end_with?('*')
 
-  type = raw.sub(/\Aconst\s+/, '').sub(/\s*&\z/, '').strip
-  map_scalar_cpp_return_type(type) || map_pointer_cpp_return_type(type, ast: ast)
+  map_scalar_cpp_return_type(type) || map_pointer_cpp_return_type(type, ast: ast) || map_qt_value_return_type(type, ast: ast)
+end
+
+def ast_qt_value_class?(ast, type)
+  return false unless ast && type.match?(/\AQ[A-Z]\w*\z/)
+  return false unless ast_class_index(ast)[:methods_by_class].key?(type)
+
+  !class_inherits?(ast, type, 'QObject')
+end
+
+def map_qt_value_return_type(type, ast:)
+  return nil unless ast_qt_value_class?(ast, type)
+
+  { ffi_return: :pointer, return_cast: :qt_value_copy, value_class: type }
 end
 
 def map_scalar_cpp_return_type(type)
@@ -135,7 +155,7 @@ def parse_method_signature(method_decl)
   }
 end
 
-def build_auto_method_args(parsed, entry, qt_class, int_cast_types)
+def build_auto_method_args(parsed, entry, qt_class, int_cast_types, ast)
   arg_cast_overrides = Array(entry[:arg_casts])
   params = parsed[:params]
   required_arg_count = 0
@@ -143,7 +163,7 @@ def build_auto_method_args(parsed, entry, qt_class, int_cast_types)
 
   params.each_with_index do |param, idx|
     cast_override = arg_cast_overrides[idx]
-    arg_info = map_cpp_arg_type(param[:type], qt_class: qt_class, int_cast_types: int_cast_types)
+    arg_info = map_cpp_arg_type(param[:type], qt_class: qt_class, int_cast_types: int_cast_types, ast: ast)
     arg_info ||= { ffi: :int } if cast_override
     unless arg_info
       return nil unless skip_unsupported_optional_tail?(params, idx, param)
@@ -151,7 +171,12 @@ def build_auto_method_args(parsed, entry, qt_class, int_cast_types)
       break
     end
 
-    args << { name: param[:name], ffi: arg_info[:ffi], cast: cast_override || arg_info[:cast] }.compact
+    args << {
+      name: param[:name],
+      ffi: arg_info[:ffi],
+      cast: cast_override || arg_info[:cast],
+      value_class: arg_info[:value_class]
+    }.compact
     required_arg_count += 1 unless param[:has_default]
   end
 
@@ -174,6 +199,7 @@ def build_auto_method_hash(entry, ret_info, args, required_arg_count)
   }
   method[:return_cast] = ret_info[:return_cast] if ret_info[:return_cast]
   method[:pointer_class] = ret_info[:pointer_class] if ret_info[:pointer_class]
+  method[:value_class] = ret_info[:value_class] if ret_info[:value_class]
   method
 end
 
@@ -184,7 +210,7 @@ def build_auto_method_from_decl(method_decl, entry, qt_class:, int_cast_types:,
   ret_info = map_cpp_return_type(parsed[:return_type], ast: ast)
   return nil unless ret_info
 
-  args, required_arg_count = build_auto_method_args(parsed, entry, qt_class, int_cast_types)
+  args, required_arg_count = build_auto_method_args(parsed, entry, qt_class, int_cast_types, ast)
   return nil unless args
 
   build_auto_method_hash(entry, ret_info, args, required_arg_count)
@@ -352,7 +378,11 @@ def resolve_auto_method(ast, qt_class, auto_entry)
   built = resolve_auto_method_built_candidates(ast, qt_class, entry)
   return per_ast_cache[cache_key] = nil unless built
 
-  per_ast_cache[cache_key] = built.min_by { |candidate| candidate[:method][:args].length }[:method]
+  per_ast_cache[cache_key] = built.min_by do |candidate|
+    method = candidate[:method]
+    value_arg_count = method[:args].count { |arg| arg[:cast] == :qt_value_ref }
+    [value_arg_count, method[:args].length]
+  end[:method]
 end
 
 def auto_entries_for_spec(spec, ast)

data/scripts/generate_bridge/core_utils.rb

@@ -109,6 +109,10 @@ def ctor_function_name(spec)
   "qt_ruby_#{spec[:prefix]}_new"
 end
 
-def method_function_name(spec, method)
+def default_method_function_name(spec, method)
   "qt_ruby_#{spec[:prefix]}_#{to_snake(method[:qt_name])}"
 end
+
+def method_function_name(spec, method)
+  method[:native_name] || default_method_function_name(spec, method)
+end

data/scripts/generate_bridge/cpp_method_return_emitter.rb

@@ -10,6 +10,8 @@ class CppMethodReturnEmitter
 
   def emit
     return emit_void if method[:ffi_return] == :void
+    return emit_qt_value_copy if method[:return_cast] == :qt_value_copy
+    return emit_qint_list if method[:return_cast] == :qint_list_to_variant
     return emit_qstring if qstring_return?
     return emit_qobject_list if qobject_list_return?
     return emit_qdatetime if qdatetime_return?
@@ -54,52 +56,86 @@ class CppMethodReturnEmitter
   end
 
   def emit_qstring
-    lines << "  const QString value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = value.toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QString #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = #{result}.toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_qvariant
-    lines << "  const QVariant value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = qvariant_to_bridge_string(value).toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QVariant #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qvariant_to_bridge_string(#{result}).toUtf8();"
+    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();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QObjectList #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qobject_list_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_qdatetime
-    lines << "  const QDateTime value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = qdatetime_to_bridge_string(value).toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QDateTime #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qdatetime_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_qdate
-    lines << "  const QDate value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = qdate_to_bridge_string(value).toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QDate #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qdate_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_qtime
-    lines << "  const QTime value = #{invocation};"
-    lines << '  thread_local QByteArray utf8;'
-    lines << '  utf8 = qtime_to_bridge_string(value).toUtf8();'
-    lines << '  return utf8.constData();'
+    result = unique_local_name('result')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QTime #{result} = #{invocation};"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qtime_to_bridge_string(#{result}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
   end
 
   def emit_pointer
     lines << "  return const_cast<void*>(static_cast<const void*>(#{invocation}));"
   end
 
+  def emit_qt_value_copy
+    lines << "  return new #{method[:value_class]}(#{invocation});"
+  end
+
+  def emit_qint_list
+    result = unique_local_name('result')
+    variant = unique_local_name('variant')
+    utf8 = unique_local_name('utf8')
+    lines << "  const QList<int> #{result} = #{invocation};"
+    lines << "  const QVariant #{variant} = QtRubyRuntime::qvariant_from_qint_list(#{result});"
+    lines << "  thread_local QByteArray #{utf8};"
+    lines << "  #{utf8} = qvariant_to_bridge_string(#{variant}).toUtf8();"
+    lines << "  return #{utf8}.constData();"
+  end
+
   def emit_value
     lines << "  return #{invocation};"
   end
+
+  def unique_local_name(suffix)
+    used = Array(method[:args]).map { |arg| arg[:name].to_s }.to_set
+    candidate = "qt_ruby_#{suffix}"
+    candidate += '_' while used.include?(candidate)
+    candidate
+  end
 end

data/scripts/generate_bridge/ffi_api.rb

@@ -15,9 +15,25 @@ def all_ffi_functions(specs, free_function_specs:)
     append_method_ffi_functions(fns, spec)
   end
 
+  value_wrapper_classes(specs, free_function_specs: free_function_specs).each do |qt_class|
+    fns << { name: qt_value_delete_function_name(qt_class), ffi_return: :void, args: [:pointer] }
+  end
+
   fns
 end
 
+def value_wrapper_classes(specs, free_function_specs: [])
+  spec_classes = specs.flat_map do |spec|
+    spec[:methods].filter_map { |method| method[:value_class] if method[:return_cast] == :qt_value_copy }
+  end
+  free_classes = free_function_specs.filter_map { |spec| spec[:value_class] }
+  (spec_classes + free_classes).uniq.sort
+end
+
+def qt_value_delete_function_name(qt_class)
+  "qt_ruby_#{to_snake(qt_class)}_value_delete"
+end
+
 def append_constructor_ffi_function(fns, spec)
   return if spec[:constructor][:mode] == :wrap_only
 

data/scripts/generate_bridge/free_function_specs.rb

@@ -215,6 +215,8 @@ def build_qapplication_static_free_function_spec(ast, qt_name, int_cast_types)
   cpp_body =
     if candidate[:ffi_return] == :void
       ["QApplication::#{qt_name}();"]
+    elsif candidate[:return_cast] == :qt_value_copy
+      ["return new #{candidate[:value_class]}(QApplication::#{qt_name}());"]
     elsif candidate[:enum_cast]
       ["return static_cast<int>(QApplication::#{qt_name}());"]
     elsif candidate[:ffi_return] == :string
@@ -231,6 +233,7 @@ def build_qapplication_static_free_function_spec(ast, qt_name, int_cast_types)
   {
     name: "qt_ruby_#{native_name}",
     ffi_return: candidate[:ffi_return],
+    value_class: candidate[:value_class],
     args: [],
     cpp_return: ffi_return_to_cpp(candidate[:ffi_return]),
     cpp_args: '',
@@ -240,7 +243,8 @@ def build_qapplication_static_free_function_spec(ast, qt_name, int_cast_types)
       native: native_name,
       args: [],
       return_cast: candidate[:return_cast],
-      pointer_class: candidate[:pointer_class]
+      pointer_class: candidate[:pointer_class],
+      value_class: candidate[:value_class]
     }
   }
 end
@@ -271,6 +275,7 @@ def qapplication_static_return_info(return_type, int_cast_types, ast:)
       ffi_return: mapped[:ffi_return],
       return_cast: mapped[:return_cast],
       pointer_class: mapped[:pointer_class],
+      value_class: mapped[:value_class],
       enum_cast: false
     }
   end

data/scripts/generate_bridge/spec_discovery.rb

@@ -151,6 +151,90 @@ def discover_related_value_classes(ast, seed_classes, all_classes, template_clas
   discovered.to_a
 end
 
+def discover_related_qobject_wrapper_classes(ast, seed_classes, all_classes, template_classes, scope)
+  discovered = seed_classes.to_set
+  queue = seed_classes.dup
+  related = []
+
+  until queue.empty?
+    klass = queue.shift
+    related_qobject_pointer_type_names(ast, klass).each do |candidate|
+      next if discovered.include?(candidate)
+      next unless related_qobject_wrapper_candidate?(ast, candidate, all_classes, template_classes, scope)
+
+      discovered << candidate
+      related << candidate
+      queue << candidate
+    end
+  end
+
+  related
+end
+
+def related_qobject_wrapper_candidate?(ast, qt_class, all_classes, template_classes, scope)
+  return false unless all_classes.include?(qt_class)
+  return false if template_classes.include?(qt_class)
+  return false if qt_class.end_with?('Private')
+  return false if qt_class == 'QApplication'
+  return false unless class_inherits?(ast, qt_class, 'QObject')
+
+  related_qobject_wrapper_matches_scope?(ast, qt_class, scope)
+end
+
+def related_qobject_wrapper_matches_scope?(ast, qt_class, scope)
+  case scope
+  when 'widgets'
+    class_inherits?(ast, qt_class, 'QWidget') || class_inherits?(ast, qt_class, 'QLayout')
+  when 'qobject'
+    !class_inherits?(ast, qt_class, 'QWidget') && !class_inherits?(ast, qt_class, 'QLayout')
+  when 'all'
+    true
+  else
+    raise "Unsupported QT_RUBY_SCOPE=#{scope.inspect}. Supported: #{SUPPORTED_SCOPES.join(', ')}"
+  end
+end
+
+def related_qobject_pointer_type_names(ast, qt_class)
+  int_cast_types = ast_int_cast_type_set(ast)
+  method_decls_for_related_wrapper_scan(ast, qt_class).each_with_object(Set.new) do |decl, out|
+    next unless auto_method_decl_candidate?(decl)
+    next unless auto_method_supported_for_related_wrapper_scan?(ast, decl, qt_class, int_cast_types)
+
+    parsed = parse_method_signature(decl)
+    append_qobject_pointer_types_from_decl(out, parsed)
+  end
+end
+
+def method_decls_for_related_wrapper_scan(ast, qt_class)
+  collect_method_names_with_bases(ast, qt_class).flat_map do |method_name|
+    collect_method_decls_with_bases(ast, qt_class, method_name)
+  end
+end
+
+def auto_method_supported_for_related_wrapper_scan?(ast, decl, qt_class, int_cast_types)
+  entry = { qt_name: decl['name'] }
+  !build_auto_method_from_decl(decl, entry, qt_class: qt_class, int_cast_types: int_cast_types, ast: ast).nil?
+end
+
+def append_qobject_pointer_types_from_decl(out, parsed)
+  pointer_type = qobject_pointer_type_name(parsed[:return_type])
+  out << pointer_type if pointer_type
+  parsed[:params].each do |param|
+    pointer_type = qobject_pointer_type_name(param[:type])
+    out << pointer_type if pointer_type
+  end
+end
+
+def qobject_pointer_type_name(raw_type)
+  normalized = normalized_cpp_type_name(raw_type).to_s
+  return nil unless normalized.end_with?('*')
+
+  type_name = normalized.delete_suffix('*')
+  return nil unless type_name.match?(/\AQ[A-Z]\w*\z/)
+
+  type_name
+end
+
 def related_value_class_candidate?(ast, qt_class, all_classes, template_classes)
   return false if SCALAR_BRIDGED_QT_TYPES.include?(qt_class)
   return false unless all_classes.include?(qt_class)
@@ -215,9 +299,14 @@ def discover_target_qt_classes(ast, scope)
   targets = timed("discover_target_qt_classes/#{scope}/related") do
     discover_related_value_classes(ast, base_targets, all_classes, template_classes).sort
   end
+  wrapper_targets = timed("discover_target_qt_classes/#{scope}/related_qobject_wrappers") do
+    seed_classes = (targets + ['QApplication']).uniq
+    discover_related_qobject_wrapper_classes(ast, seed_classes, all_classes, template_classes, scope).sort
+  end
+  targets = (targets + wrapper_targets).uniq.sort
   debug_log(
     "discover_target_qt_classes scope=#{scope} total_q=#{all_classes.length} " \
-    "base=#{base_targets.length} targets=#{targets.length}"
+    "base=#{base_targets.length} wrappers=#{wrapper_targets.length} targets=#{targets.length}"
   )
   targets
 end
@@ -264,7 +353,7 @@ def constructor_usable_for_codegen?(ast, qt_class)
   ctor_decls = collect_constructor_decls(ast, qt_class)
   ctor_decls.any? do |decl|
     constructor_keysequence_parent_type(decl) ||
-    constructor_supports_parent_only?(decl) ||
+      constructor_supports_parent_only?(decl) ||
       constructor_supports_no_args?(decl) ||
       constructor_supports_string_path?(decl)
   end
@@ -272,28 +361,40 @@ end
 
 def build_base_spec_for_qt_class(ast, qt_class)
   ctor_decls = collect_constructor_decls(ast, qt_class)
+  parent_ctor = if abstract_class?(ast, qt_class)
+                  { parent: false, mode: :wrap_only }
+                else
+                  constructor_spec_for_qt_class(ast, qt_class, ctor_decls)
+                end
+  base_spec_hash(qt_class, parent_ctor)
+end
+
+def constructor_spec_for_qt_class(ast, qt_class, ctor_decls)
   keysequence_parent_type = ctor_decls.filter_map { |decl| constructor_keysequence_parent_type(decl) }.first
   parent_type = ctor_decls.filter_map { |decl| parent_constructor_first_type(decl) }.first
-  string_path_cast = ctor_decls.filter_map do |decl|
+  string_path_cast = constructor_string_path_cast(ctor_decls)
+  widget_child = qt_class != 'QWidget' && class_inherits?(ast, qt_class, 'QWidget')
+
+  if keysequence_parent_type
+    { parent: true, parent_type: keysequence_parent_type, mode: :keysequence_parent, register_in_parent: widget_child }
+  elsif parent_type
+    parent_constructor_for_type(parent_type, widget_child)
+  elsif string_path_cast
+    string_path_constructor(string_path_cast)
+  elsif ctor_decls.any? { |decl| constructor_supports_no_args?(decl) }
+    { parent: false }
+  else
+    { parent: false, mode: :wrap_only }
+  end
+end
+
+def constructor_string_path_cast(ctor_decls)
+  ctor_decls.filter_map do |decl|
     parsed = parse_method_signature(decl)
     next nil unless parsed && parsed[:params].first
 
     constructor_string_like_arg_cast(parsed[:params].first[:type])
   end.first
-  widget_child = qt_class != 'QWidget' && class_inherits?(ast, qt_class, 'QWidget')
-  parent_ctor =
-    if keysequence_parent_type
-      { parent: true, parent_type: keysequence_parent_type, mode: :keysequence_parent, register_in_parent: widget_child }
-    elsif parent_type
-      parent_constructor_for_type(parent_type, widget_child)
-    elsif string_path_cast
-      string_path_constructor(string_path_cast)
-    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
 
 def base_spec_hash(qt_class, parent_ctor)

data/scripts/generate_bridge.rb

@@ -250,7 +250,9 @@ def arg_expr(arg)
   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]})"
+  when :qint_list_from_variant then "QtRubyRuntime::qint_list_from_variant(qvariant_from_bridge_value(#{arg[:name]}))"
   when :alignment then "static_cast<Qt::Alignment>(#{arg[:name]})"
+  when :qt_value_ref then "*static_cast<#{arg[:value_class]}*>(#{arg[:name]})"
   when String then "static_cast<#{arg[:cast]}>(#{arg[:name]})"
   else
     arg[:name]
@@ -335,6 +337,15 @@ def generate_cpp_delete(lines)
   lines << '}'
 end
 
+def generate_cpp_qt_value_deletes(lines, specs, free_function_specs)
+  value_wrapper_classes(specs, free_function_specs: free_function_specs).each do |qt_class|
+    lines << "extern \"C\" void #{qt_value_delete_function_name(qt_class)}(void* handle) {"
+    lines << "  delete static_cast<#{qt_class}*>(handle);"
+    lines << '}'
+    lines << ''
+  end
+end
+
 def cpp_method_signature(method)
   ['void* handle'] + method[:args].map { |arg| "#{ffi_to_cpp_type(arg[:ffi])} #{arg[:name]}" }
 end
@@ -381,6 +392,7 @@ def generate_cpp_bridge(specs, free_function_specs)
 
   specs.each { |spec| append_cpp_spec_methods(lines, spec) }
 
+  generate_cpp_qt_value_deletes(lines, specs, free_function_specs)
   generate_cpp_delete(lines)
   "#{lines.join("\n")}\n"
 end
@@ -640,6 +652,7 @@ def optional_arg_replacement(arg, safe)
   when :bool then "(#{safe}.nil? ? false : #{safe})"
   when :pointer then safe
   when :string
+    return "(#{safe}.nil? ? Qt::VariantCodec.encode([]) : Qt::VariantCodec.encode(#{safe}))" if arg[:cast] == :qint_list_from_variant
     return "(#{safe}.nil? ? '' : Qt::VariantCodec.encode(#{safe}))" if arg[:cast] == :qvariant_from_utf8
     return "(#{safe}.nil? ? '' : Qt::DateTimeCodec.encode_qdatetime(#{safe}))" if arg[:cast] == :qdatetime_from_utf8
     return "(#{safe}.nil? ? '' : Qt::DateTimeCodec.encode_qdate(#{safe}))" if arg[:cast] == :qdate_from_utf8
@@ -653,8 +666,13 @@ def optional_arg_replacement(arg, safe)
 end
 
 def ruby_arg_call_value(arg, safe, optional:)
+  if arg[:cast] == :qt_value_ref
+    return optional ? "(#{safe}.nil? ? nil : #{safe}.handle)" : "#{safe}.handle"
+  end
+
   return "Qt::StringCodec.to_qt_text(#{safe})" if text_bridge_arg?(arg) && !optional
   return "Qt::VariantCodec.encode(#{safe})" if arg[:cast] == :qvariant_from_utf8 && !optional
+  return "Qt::VariantCodec.encode(#{safe})" if arg[:cast] == :qint_list_from_variant && !optional
   return "Qt::DateTimeCodec.encode_qdatetime(#{safe})" if arg[:cast] == :qdatetime_from_utf8 && !optional
   return "Qt::DateTimeCodec.encode_qdate(#{safe})" if arg[:cast] == :qdate_from_utf8 && !optional
   return "Qt::DateTimeCodec.encode_qtime(#{safe})" if arg[:cast] == :qtime_from_utf8 && !optional
@@ -698,9 +716,14 @@ def ruby_native_method_body(method, rewritten_native_call)
     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::VariantCodec.decode(#{rewritten_native_call})" if method[:return_cast] == :qint_list_to_variant
   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
   return "Qt::DateTimeCodec.decode_qtime(#{rewritten_native_call})" if method[:return_cast] == :qtime_to_utf8
+  if method[:return_cast] == :qt_value_copy
+    delete_method = qt_value_delete_function_name(method[:value_class])
+    return "Qt::ValueWrapper.wrap(#{rewritten_native_call}, '#{method[:value_class]}', :#{delete_method})"
+  end
   return "Qt::ObjectWrapper.wrap(#{rewritten_native_call}, '#{method[:pointer_class]}')" if method[:pointer_class]
 
   rewritten_native_call
@@ -899,6 +922,11 @@ def qapplication_class_method_body(method, native_call)
   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
+  return "        Qt::VariantCodec.decode(#{native_call})" if method[:return_cast] == :qint_list_to_variant
+  if method[:return_cast] == :qt_value_copy
+    delete_method = qt_value_delete_function_name(method[:value_class])
+    return "        Qt::ValueWrapper.wrap(#{native_call}, '#{method[:value_class]}', :#{delete_method})"
+  end
   return "        Qt::ObjectWrapper.wrap(#{native_call}, '#{method[:pointer_class]}')" if method[:pointer_class]
 
   "        #{native_call}"
@@ -920,13 +948,50 @@ end
 def append_ruby_widget_methods(lines, spec)
   spec[:methods].each do |method|
     call_args = ['@handle'] + method[:args].map { |arg| arg[:name] }
-    native_call = "Native.#{spec[:prefix]}_#{to_snake(method[:qt_name])}(#{call_args.join(', ')})"
+    native_name = method_function_name(spec, method).delete_prefix('qt_ruby_')
+    native_call = "Native.#{native_name}(#{call_args.join(', ')})"
     append_ruby_native_call_method(lines, method: method, native_call: native_call, indent: '    ')
     append_ruby_property_writer(lines, method: method, indent: '    ')
     lines << ''
   end
 end
 
+def assign_unique_native_method_names(specs)
+  used = Set.new
+  specs.map do |spec|
+    methods = spec[:methods].map do |method|
+      assign_unique_native_method_name(spec, method, used)
+    end
+    spec.merge(methods: methods)
+  end
+end
+
+def assign_unique_native_method_name(spec, method, used)
+  native_name = default_method_function_name(spec, method)
+  return used_add_and_return(used, native_name, method) unless used.include?(native_name)
+
+  unique_name = next_unique_native_method_name(spec, method, used)
+  debug_log("native name collision #{native_name} -> #{unique_name}")
+  used << unique_name
+  method.merge(native_name: unique_name)
+end
+
+def used_add_and_return(used, value, result)
+  used << value
+  result
+end
+
+def next_unique_native_method_name(spec, method, used)
+  base = "qt_ruby_#{spec[:prefix]}_qt_#{to_snake(method[:qt_name])}"
+  candidate = base
+  counter = 2
+  while used.include?(candidate)
+    candidate = "#{base}_#{counter}"
+    counter += 1
+  end
+  candidate
+end
+
 def generate_ruby_widget_class(lines, spec, specs_by_qt, super_qt_by_qt, qt_to_ruby)
   metadata = ruby_api_metadata_for_spec(spec, specs_by_qt, super_qt_by_qt)
   super_ruby = ruby_super_class_for_spec(spec, super_qt_by_qt, qt_to_ruby)
@@ -1136,6 +1201,7 @@ def collect_qt_scoped_enum_constants(ast, warnings = [])
     next unless owner.match?(/\AQ[A-Z]\w*\z/)
     next if owner == 'Qt' || owner == 'QEvent'
 
+    next_value = 0
     Array(node['inner']).each do |entry|
       next unless entry['kind'] == 'EnumConstantDecl'
 
@@ -1144,7 +1210,13 @@ def collect_qt_scoped_enum_constants(ast, warnings = [])
 
       raw_value = ast_extract_first_value(entry)
       value = parse_ast_integer_value(raw_value)
-      next if value.nil?
+      value = next_value if value.nil? && !next_value.nil?
+      if value.nil?
+        next_value = nil
+        next
+      end
+
+      next_value = value + 1
 
       append_constant_with_conflict_warning(
         constants_by_owner[owner],
@@ -1202,7 +1274,8 @@ free_function_specs = timed('build_free_function_specs') { qt_free_function_spec
 base_specs = timed('build_base_specs') { build_base_specs(ast) }
 timed('validate_qt_api') { validate_qt_api!(ast, base_specs) }
 expanded_specs = timed('expand_auto_methods') { expand_auto_methods(base_specs, ast) }
-effective_specs = timed('enrich_specs_with_properties') { enrich_specs_with_properties(expanded_specs, ast) }
+property_specs = timed('enrich_specs_with_properties') { enrich_specs_with_properties(expanded_specs, ast) }
+effective_specs = timed('assign_unique_native_method_names') { assign_unique_native_method_names(property_specs) }
 super_qt_by_qt, wrapper_qt_classes = timed('build_generated_inheritance') do
   build_generated_inheritance(ast, effective_specs)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qt
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.0
 platform: ruby
 authors:
 - Maksim Veynberg
@@ -47,6 +47,7 @@ files:
 - ext/qt_ruby_bridge/qt_ruby_runtime.hpp
 - ext/qt_ruby_bridge/runtime_events.cpp
 - ext/qt_ruby_bridge/runtime_signals.cpp
+- ext/qt_ruby_bridge/runtime_value_types.cpp
 - lib/qt.rb
 - lib/qt/application_lifecycle.rb
 - lib/qt/bridge.rb
@@ -66,6 +67,7 @@ files:
 - lib/qt/object_wrapper.rb
 - lib/qt/shortcut_compat.rb
 - lib/qt/string_codec.rb
+- lib/qt/value_wrapper.rb
 - lib/qt/variant_codec.rb
 - lib/qt/version.rb
 - scripts/generate_bridge.rb
@@ -100,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Ruby bindings for Qt 6.4.2+
 test_files: []