qt 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be7294fb17e8d0cd4eeb66cc86fe6ee91940a95d5a6f3afaf9dfa44fb54445ba
-  data.tar.gz: 20683a100daf8ca9299a2227ae2605acbde2393e2444d020625c058cbc76993c
+  metadata.gz: 50d48e8571c76d7413f893a6189b7670629bd3a80123a131bf9cc00ffe6d818e
+  data.tar.gz: bcb0081e9ebabc04175f7f041fdf8442293d08191e5ee6e2b26164d32c730942
 SHA512:
-  metadata.gz: 151a6423964153f8e5f54cba0cc7c54d1ff6b4a7fbd10b003d2a19f6263831493d18ed6fbaeabf88d5791d3e3326e356ba50e0d5332e212c75341bf6ea3c2f50
-  data.tar.gz: 9e7542fc4bc481b7c3110f4b55aa4b33dd327babbe4aaad3dc4078ce2bd404a97a90022f1e49d97bd3ae05cb805e4db8fd0aef13e368974505dc361d29edfdd9
+  metadata.gz: 82bde56dd8d499bfc122923554109e6f7f92dfea399ed6fd2f821737c29cfb487b0025908409273aeb13df2ca9ed57a36eb524142a968c24a84eba43af4836b3
+  data.tar.gz: 0444cabcb5c8ce71559758e92168f0f357de967edaaf15671f5f867f7e115dc48615e49de6d4d9a3fa55c7d098da46460b810ec0ac07ff625922c724daeac575

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,10 +51,10 @@ 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[
@@ -52,8 +69,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/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
@@ -65,7 +68,6 @@ module Qt
       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
@@ -87,6 +89,7 @@ module Qt
 
       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
@@ -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]
@@ -157,6 +188,10 @@ module Qt
       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?
 

data/lib/qt/version.rb

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

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'
@@ -95,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/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/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

@@ -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)
@@ -160,7 +244,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 +262,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 +280,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)
@@ -206,9 +299,13 @@ 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
+    discover_related_qobject_wrapper_classes(ast, targets, 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
@@ -220,9 +317,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'
@@ -240,7 +352,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
@@ -248,26 +360,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)
-    else
-      { parent: false }
-    end
-  base_spec_hash(qt_class, parent_ctor)
 end
 
 def base_spec_hash(qt_class, parent_ctor)

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 << ''
@@ -717,6 +720,8 @@ 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
 
@@ -747,7 +752,10 @@ def qapplication_singleton_forwarder_names(methods, singleton_setter_aliases)
 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)
@@ -761,6 +769,12 @@ 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)"
@@ -906,13 +920,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)
@@ -1049,6 +1100,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'
 
@@ -1058,9 +1110,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
 
@@ -1075,6 +1132,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
 
@@ -1179,7 +1239,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.7
+  version: 0.1.9
 platform: ruby
 authors:
 - Maksim Veynberg
@@ -100,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.10
 specification_version: 4
 summary: Ruby bindings for Qt 6.4.2+
 test_files: []