qt 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b476ba2b95707fc32d1995f8ae8dfc5c8068ab46020e00ea5442b1fb42dd3220
-  data.tar.gz: 2ffb03be131be2c47d5d89f1094600d6e52fdb6891ffaabc40a3d8d7f6356c31
+  metadata.gz: 58b685a5934b6ab65de8085da77093cf9de7b608a2f047638e6662ece29f4f8a
+  data.tar.gz: 3ce44932b8d818b1068908d73189704bdd4b1e2f54e6d2e462c83d217b81c3f3
 SHA512:
-  metadata.gz: 710c7df3d9c1950c14d35762a9223eb64cb4184573e0456fd864f5dd139f35224d03b144d0d121f465221e107e11a7c22e3053ee0b5508db72fe8e803ac3fc0c
-  data.tar.gz: b8424801d5f61607f02ad9fb48cc5e6941f4dc811a38c4dbb5439d2e9f5dc561ed1ed814ec910d9ae81e49d84bf47fd40957ecfee07bb951900c80567ba49789
+  metadata.gz: aac76dc37741b86a72be2b8b5f1d671b3f0e4fc59ad95e2958264c7a9929f3dad7d445e3bded8f46d67bc304296b0610d7f427ca19eebaec99fd41dff4d454cb
+  data.tar.gz: 50d80970f96868a576ac445b84bbf45ea002bf8c55038b52d3e0c1f2a522d89c6cf2e2120a895b43963cc912900ab63a3520be8d91278d3a8f5a6ec08e364569

data/ext/qt_ruby_bridge/qt_ruby_runtime.hpp

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

data/ext/qt_ruby_bridge/runtime_events.cpp

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

data/lib/qt/event_runtime.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Qt
   # Event/signal subscription runtime backed by generated native callbacks.
   module EventRuntime
@@ -77,13 +79,7 @@ module Qt
 
     def event_type_for(event_name)
       key = event_name.to_sym
-      map = {
-        mouse_button_press: Qt::EventMouseButtonPress, mouse_button_release: Qt::EventMouseButtonRelease,
-        mouse_move: Qt::EventMouseMove, key_press: Qt::EventKeyPress, key_release: Qt::EventKeyRelease,
-        focus_in: Qt::EventFocusIn, focus_out: Qt::EventFocusOut, enter: Qt::EventEnter,
-        leave: Qt::EventLeave, resize: Qt::EventResize
-      }
-      event_type = map[key]
+      event_type = Qt::GENERATED_EVENT_TYPES[key]
       raise ArgumentError, "unknown event: #{event_name.inspect}" unless event_type
 
       event_type
@@ -93,10 +89,9 @@ module Qt
       return if @event_callback
 
       @event_callback = FFI::Function.new(
-        :void, %i[pointer int int int int int]
-      ) do |object_handle, event_type, *args|
-        a, b, c, d = args
-        payload = { type: event_type, a: a, b: b, c: c, d: d }
+        :int, %i[pointer int string]
+      ) do |object_handle, event_type, payload_json|
+        payload = decode_event_payload(event_type, payload_json)
         EventRuntimeDispatch.dispatch_event(@event_handlers, object_handle, event_type, payload)
       end
 
@@ -120,6 +115,17 @@ module Qt
       widget.respond_to?(:handle) ? widget.handle : widget
     end
 
+    def decode_event_payload(event_type, payload_json)
+      payload =
+        if payload_json.nil? || payload_json.empty?
+          {}
+        else
+          JSON.parse(Qt::StringCodec.from_qt_text(payload_json), symbolize_names: true)
+        end
+      payload[:type] ||= event_type
+      payload
+    end
+
     def ensure_native_bridge_ready!
       Qt::Native.ensure_loaded!
       Qt::Native.define_bridge_wrappers!

data/lib/qt/event_runtime_dispatch.rb

@@ -4,18 +4,26 @@
 module Qt
   # Dispatch helpers for event/signal callbacks from the native bridge.
   module EventRuntimeDispatch
+    EVENT_RESULT_IGNORE = 0
+    EVENT_RESULT_CONTINUE = 1
+    EVENT_RESULT_CONSUME = 2
+
     module_function
 
     def dispatch_event(event_handlers, object_handle, event_type, payload)
-      return unless object_handle && event_handlers
+      return EVENT_RESULT_CONTINUE unless object_handle && event_handlers
 
       per_widget = event_handlers[object_handle.address]
-      return unless per_widget
+      return EVENT_RESULT_CONTINUE unless per_widget
 
       handlers = per_widget[event_type]
-      return unless handlers && !handlers.empty?
+      return EVENT_RESULT_CONTINUE unless handlers && !handlers.empty?
+
+      results = handlers.map { |handler| handler.call(payload) }
+      return EVENT_RESULT_CONSUME if results.any? { |result| result == true || result == :consume }
+      return EVENT_RESULT_IGNORE if results.any? { |result| result == false || result == :ignore }
 
-      handlers.each { |handler| handler.call(payload) }
+      EVENT_RESULT_CONTINUE
     end
 
     def dispatch_signal(signal_handlers, object_handle, signal_index, payload)

data/lib/qt/version.rb

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

data/lib/qt.rb

@@ -8,8 +8,10 @@ GENERATED_DIR = File.join(ROOT, 'build', 'generated')
 GENERATED_WIDGETS = File.join(GENERATED_DIR, 'widgets.rb')
 GENERATED_API = File.join(GENERATED_DIR, 'bridge_api.rb')
 GENERATED_CONSTANTS = File.join(GENERATED_DIR, 'constants.rb')
+GENERATED_EVENT_PAYLOADS = File.join(GENERATED_DIR, 'event_payloads.rb')
 
-unless File.exist?(GENERATED_WIDGETS) && File.exist?(GENERATED_API) && File.exist?(GENERATED_CONSTANTS)
+unless File.exist?(GENERATED_WIDGETS) && File.exist?(GENERATED_API) && File.exist?(GENERATED_CONSTANTS) &&
+       File.exist?(GENERATED_EVENT_PAYLOADS)
   ok = system(RbConfig.ruby, GENERATOR)
   raise 'Failed to generate Qt Ruby bindings. Run: bundle exec rake compile' unless ok
 end
@@ -30,6 +32,7 @@ require_relative 'qt/native'
 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
 require_relative 'qt/shortcut_compat'
 Qt::GeneratedConstantsRuntime.apply_generated_scoped_constants!(Qt)

data/scripts/generate_bridge/event_payloads.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+EVENT_PAYLOAD_COMPATIBILITY_ALIASES = {
+  'QMouseEvent' => { a: :x, b: :y, c: :button, d: :buttons },
+  'QKeyEvent' => { a: :key, b: :modifiers, c: :is_auto_repeat, d: :count },
+  'QResizeEvent' => { a: :width, b: :height, c: :old_width, d: :old_height },
+  'QWheelEvent' => { a: :pixel_delta_y, b: :angle_delta_y, c: :buttons, d: nil }
+}.freeze
+
+EVENT_PAYLOAD_EXCLUDED_METHODS = %w[
+  accepted clone ignore isAccepted registerEventType setAccepted spontaneous type
+].freeze
+
+EVENT_PAYLOAD_SUPPORTED_COMPLEX_TYPES = %w[QPoint QPointF QSize].freeze
+
+def event_payload_class_names(ast)
+  @event_payload_class_names ||= {}.compare_by_identity
+  return @event_payload_class_names[ast] if @event_payload_class_names.key?(ast)
+
+  index = ast_class_index(ast)
+  @event_payload_class_names[ast] = index[:methods_by_class].keys.select do |class_name|
+    class_name.start_with?('Q') && class_name.end_with?('Event') && class_inherits?(ast, class_name, 'QEvent')
+  end.sort
+end
+
+def event_payload_ctor_type_param?(ctor_decl)
+  Array(ctor_decl['inner']).any? do |node|
+    next false unless node['kind'] == 'ParmVarDecl'
+
+    raw_type = node.dig('type', 'desugaredQualType') || node.dig('type', 'qualType')
+    name = node['name']
+    %w[type t].include?(name) && %w[Type QEvent::Type].include?(raw_type)
+  end
+end
+
+def event_payload_type_family_class_names(ast)
+  @event_payload_type_family_class_names ||= {}.compare_by_identity
+  return @event_payload_type_family_class_names[ast] if @event_payload_type_family_class_names.key?(ast)
+
+  @event_payload_type_family_class_names[ast] = event_payload_class_names(ast).select do |class_name|
+    collect_constructor_decls(ast, class_name).any? { |decl| event_payload_ctor_type_param?(decl) }
+  end
+end
+
+def event_payload_class_stem(class_name)
+  class_name.sub(/\AQ/, '').sub(/Event\z/, '')
+end
+
+def event_payload_camel_tokens(name)
+  name.to_s.scan(/[A-Z]+(?=[A-Z][a-z]|\z)|[A-Z]?[a-z]+|\d+/)
+end
+
+def event_payload_token_sequence_present?(haystack, needle)
+  return false if haystack.empty? || needle.empty? || needle.length > haystack.length
+
+  0.upto(haystack.length - needle.length).any? do |start_idx|
+    haystack[start_idx, needle.length] == needle
+  end
+end
+
+def event_payload_family_match?(event_name, class_name, mode)
+  event_tokens = event_payload_camel_tokens(event_name)
+  class_tokens = event_payload_camel_tokens(event_payload_class_stem(class_name))
+  return false if event_tokens.empty? || class_tokens.empty?
+
+  event_downcase = event_tokens.map(&:downcase)
+  class_downcase = class_tokens.map(&:downcase)
+  event_compact = event_downcase.join
+  class_compact = class_downcase.join
+
+  case mode
+  when :prefix
+    event_downcase.first(class_downcase.length) == class_downcase
+  when :suffix
+    event_downcase.last(class_downcase.length) == class_downcase
+  when :contiguous_tokens
+    event_payload_token_sequence_present?(event_downcase, class_downcase)
+  when :compact_substring
+    event_compact.include?(class_compact)
+  else
+    false
+  end
+end
+
+def event_payload_most_specific_class_names(ast, class_names)
+  class_names.reject do |class_name|
+    class_names.any? do |other|
+      next false if other == class_name
+
+      class_inherits?(ast, other, class_name)
+    end
+  end
+end
+
+def event_payload_longest_stem_class_names(class_names)
+  stems = class_names.to_h do |class_name|
+    [class_name, event_payload_camel_tokens(event_payload_class_stem(class_name)).length]
+  end
+  longest = stems.values.max
+  class_names.select { |class_name| stems[class_name] == longest }
+end
+
+def resolve_event_payload_family_class_name(ast, event_name, warnings)
+  %i[prefix suffix contiguous_tokens compact_substring].each do |mode|
+    matches = event_payload_type_family_class_names(ast).select do |class_name|
+      event_payload_family_match?(event_name, class_name, mode)
+    end
+    next if matches.empty?
+
+    matches = event_payload_most_specific_class_names(ast, matches)
+    matches = event_payload_longest_stem_class_names(matches)
+    return matches.first if matches.length == 1
+
+    warnings << "Qt::EventPayload: ambiguous #{mode} family match for #{event_name}: #{matches.sort.join(', ')}"
+    return nil
+  end
+
+  nil
+end
+
+def resolve_event_payload_class_name(ast, event_name, warnings = [])
+  exact_class_name = "Q#{event_name}Event"
+  return exact_class_name if event_payload_class_names(ast).include?(exact_class_name)
+
+  resolve_event_payload_family_class_name(ast, event_name, warnings)
+end
+
+def supported_event_payload_return?(return_type, int_cast_types)
+  return true if event_payload_scalar_return?(return_type, int_cast_types)
+  return true if EVENT_PAYLOAD_SUPPORTED_COMPLEX_TYPES.include?(normalized_cpp_type_name(return_type))
+
+  false
+end
+
+def event_payload_scalar_return?(return_type, int_cast_types)
+  raw = return_type.to_s.strip
+  return true if %w[bool int QString double float].include?(normalized_cpp_type_name(raw))
+
+  compact = raw.sub(/\Aconst\s+/, '').sub(/\s*&\z/, '').strip
+  compact.include?('::') && int_cast_types.include?(compact)
+end
+
+def event_payload_method_decl(ast, class_name, method_name, int_cast_types)
+  collect_method_decls_with_bases(ast, class_name, method_name).find do |decl|
+    next false unless decl['__effective_access'] == 'public'
+    next false if deprecated_method_decl?(decl)
+
+    parsed = parse_method_signature(decl)
+    next false unless parsed && parsed[:params].empty?
+    next false if EVENT_PAYLOAD_EXCLUDED_METHODS.include?(method_name)
+
+    supported_event_payload_return?(parsed[:return_type], int_cast_types)
+  end
+end
+
+def event_payload_method_candidates(ast, class_name, int_cast_types)
+  collect_method_names_with_bases(ast, class_name).sort.filter_map do |method_name|
+    decl = event_payload_method_decl(ast, class_name, method_name, int_cast_types)
+    next unless decl
+
+    parsed = parse_method_signature(decl)
+    { method_name: method_name, return_type: parsed[:return_type] }
+  end
+end
+
+def event_payload_base_name(method_name, return_type)
+  normalized = normalized_cpp_type_name(return_type)
+  snake = to_snake(method_name)
+  return '' if %w[QPoint QPointF].include?(normalized) && %w[position pos local_pos].include?(snake)
+  return 'global_' if %w[QPoint QPointF].include?(normalized) && %w[global_position global_pos].include?(snake)
+  return '' if normalized == 'QSize' && snake == 'size'
+  return 'old_' if normalized == 'QSize' && snake == 'old_size'
+
+  "#{snake}_"
+end
+
+def event_payload_fields_for_method(method_name, return_type, int_cast_types)
+  normalized = normalized_cpp_type_name(return_type)
+  base_name = event_payload_base_name(method_name, return_type)
+  getter = "typed_event->#{method_name}()"
+
+  case normalized
+  when 'bool'
+    [{ name: to_snake(method_name), cpp_expr: getter, json_type: :bool }]
+  when 'int'
+    [{ name: to_snake(method_name), cpp_expr: getter, json_type: :int }]
+  when 'QString'
+    [{ name: to_snake(method_name), cpp_expr: getter, json_type: :string }]
+  when 'double', 'float'
+    [{ name: to_snake(method_name), cpp_expr: getter, json_type: :float }]
+  when 'QPoint'
+    [
+      { name: "#{base_name}x", cpp_expr: "#{getter}.x()", json_type: :int },
+      { name: "#{base_name}y", cpp_expr: "#{getter}.y()", json_type: :int }
+    ]
+  when 'QPointF'
+    [
+      { name: "#{base_name}x", cpp_expr: "#{getter}.x()", json_type: :float },
+      { name: "#{base_name}y", cpp_expr: "#{getter}.y()", json_type: :float }
+    ]
+  when 'QSize'
+    [
+      { name: "#{base_name}width", cpp_expr: "#{getter}.width()", json_type: :int },
+      { name: "#{base_name}height", cpp_expr: "#{getter}.height()", json_type: :int }
+    ]
+  else
+    compact = return_type.to_s.sub(/\Aconst\s+/, '').sub(/\s*&\z/, '').strip
+    return [] unless compact.include?('::') && int_cast_types.include?(compact)
+
+    [{ name: to_snake(method_name), cpp_expr: "static_cast<int>(#{getter})", json_type: :int }]
+  end
+end
+
+def event_payload_compatibility_fields(class_name, field_names)
+  aliases = EVENT_PAYLOAD_COMPATIBILITY_ALIASES[class_name] || {}
+  aliases.each_with_object([]) do |(alias_name, target_name), out|
+    if target_name.nil?
+      out << { name: alias_name.to_s, source: nil, json_type: :int }
+      next
+    end
+
+    next unless field_names.include?(target_name.to_s)
+
+    out << { name: alias_name.to_s, source: target_name.to_s, json_type: :alias }
+  end
+end
+
+def collect_event_payload_schema_for(ast, event_name, event_value, int_cast_types, warnings)
+  class_name = resolve_event_payload_class_name(ast, event_name, warnings)
+  return nil if class_name.nil?
+  return nil unless ast_class_index(ast)[:methods_by_class].key?(class_name)
+
+  field_specs = event_payload_method_candidates(ast, class_name, int_cast_types).flat_map do |entry|
+    event_payload_fields_for_method(entry[:method_name], entry[:return_type], int_cast_types)
+  end
+  field_specs.uniq! { |field| field[:name] }
+
+  compatibility_fields = event_payload_compatibility_fields(class_name, field_specs.map { |field| field[:name] })
+  schema = {
+    symbol_name: qevent_symbol_name(event_name),
+    event_name: event_name,
+    event_value: event_value,
+    constant_name: "Event#{event_name}",
+    class_name: class_name,
+    fields: field_specs,
+    compatibility_fields: compatibility_fields
+  }
+
+  if field_specs.empty? && compatibility_fields.empty?
+    warnings << "Qt::EventPayload: #{event_name} resolved to #{class_name} but no payload fields were derived"
+  end
+
+  schema
+end
+
+def collect_event_payload_schemas(ast, warnings = [])
+  int_cast_types = ast_int_cast_type_set(ast)
+  collect_enum_constants_for_scope(ast, ['QEvent'], warnings).sort.filter_map do |event_name, event_value|
+    collect_event_payload_schema_for(ast, event_name, event_value, int_cast_types, warnings)
+  end
+end
+
+def generate_ruby_event_payloads(ast)
+  warnings = []
+  schemas = collect_event_payload_schemas(ast, warnings)
+  emit_generation_warnings(warnings)
+
+  lines = ['# frozen_string_literal: true', '', 'module Qt']
+  lines << '  GENERATED_EVENT_PAYLOAD_SCHEMAS = {'
+  schemas.each do |schema|
+    lines << "    #{schema[:symbol_name].inspect} => {"
+    lines << "      event_type: #{schema[:constant_name]},"
+    lines << "      event_class: '#{schema[:class_name]}',"
+    lines << '      fields: ['
+    schema[:fields].each do |field|
+      lines << "        { name: #{field[:name].inspect}, type: #{field[:json_type].inspect} },"
+    end
+    schema[:compatibility_fields].each do |field|
+      lines << "        { name: #{field[:name].inspect}, type: #{field[:json_type].inspect} },"
+    end
+    lines << '      ]'
+    lines << '    },'
+  end
+  lines << '  }.freeze unless const_defined?(:GENERATED_EVENT_PAYLOAD_SCHEMAS, false)'
+  lines << 'end'
+  "#{lines.join("\n")}\n"
+end
+
+def cpp_json_insert_lines(field, source_expr = nil)
+  expr = source_expr || field[:cpp_expr]
+  case field[:json_type]
+  when :bool, :int, :float
+    ["payload.insert(\"#{field[:name]}\", #{expr});"]
+  when :string
+    ["payload.insert(\"#{field[:name]}\", #{expr});"]
+  else
+    []
+  end
+end
+
+def generate_cpp_event_payload_extractor(ast)
+  warnings = []
+  schemas = collect_event_payload_schemas(ast, warnings)
+  emit_generation_warnings(warnings)
+
+  includes = schemas.map { |schema| "#include <#{schema[:class_name]}>" }.uniq.sort
+  lines = []
+  lines.concat(includes)
+  lines << '#include <QEvent>'
+  lines << '#include <QJsonDocument>'
+  lines << '#include <QJsonObject>'
+  lines << ''
+  lines << 'namespace QtRubyGeneratedEventPayloads {'
+  lines << 'inline QByteArray serialize_event_payload(int event_type, QEvent* event) {'
+  lines << '  QJsonObject payload;'
+  lines << '  payload.insert("type", event_type);'
+  lines << '  switch (static_cast<QEvent::Type>(event_type)) {'
+  schemas.each do |schema|
+    lines << "    case QEvent::#{schema[:event_name]}: {"
+    lines << "      auto* typed_event = static_cast<#{schema[:class_name]}*>(event);"
+    schema[:fields].each do |field|
+      cpp_json_insert_lines(field).each { |line| lines << "      #{line}" }
+    end
+    schema[:compatibility_fields].each do |field|
+      if field[:source]
+        lines << "      payload.insert(\"#{field[:name]}\", payload.value(\"#{field[:source]}\"));"
+      else
+        lines << "      payload.insert(\"#{field[:name]}\", 0);"
+      end
+    end
+    lines << '      break;'
+    lines << '    }'
+  end
+  lines << '    default:'
+  lines << '      break;'
+  lines << '  }'
+  lines << '  return QJsonDocument(payload).toJson(QJsonDocument::Compact);'
+  lines << '}'
+  lines << '}  // namespace QtRubyGeneratedEventPayloads'
+  "#{lines.join("\n")}\n"
+end

data/scripts/generate_bridge.rb

@@ -13,6 +13,8 @@ CPP_PATH = File.join(GENERATED_DIR, 'qt_ruby_bridge.cpp')
 API_PATH = File.join(GENERATED_DIR, 'bridge_api.rb')
 RUBY_WIDGETS_PATH = File.join(GENERATED_DIR, 'widgets.rb')
 RUBY_CONSTANTS_PATH = File.join(GENERATED_DIR, 'constants.rb')
+RUBY_EVENT_PAYLOADS_PATH = File.join(GENERATED_DIR, 'event_payloads.rb')
+CPP_EVENT_PAYLOADS_PATH = File.join(GENERATED_DIR, 'event_payloads.inc')
 
 # Universal generation policy: class set is discovered from AST per scope.
 GENERATOR_SCOPE = (ENV['QT_RUBY_SCOPE'] || 'all').freeze
@@ -50,6 +52,7 @@ require_relative 'generate_bridge/auto_method_spec_resolver'
 require_relative 'generate_bridge/cpp_method_return_emitter'
 require_relative 'generate_bridge/ast_introspection'
 require_relative 'generate_bridge/auto_methods'
+require_relative 'generate_bridge/event_payloads'
 require_relative 'generate_bridge/spec_discovery'
 
 def next_trace_base(fetch_bases, cur, visited)
@@ -1017,6 +1020,30 @@ def collect_qt_namespace_enum_constants(ast, warnings = [])
   constants
 end
 
+def qevent_symbol_name(name)
+  to_snake(name).to_sym
+end
+
+def collect_qevent_symbol_map(ast, warnings = [])
+  symbol_map = {}
+
+  collect_enum_constants_for_scope(ast, ['QEvent'], warnings).each do |name, value|
+    symbol_name = qevent_symbol_name(name)
+    existing = symbol_map[symbol_name]
+    if existing.nil?
+      symbol_map[symbol_name] = { constant_name: "Event#{name}", value: value }
+      next
+    end
+
+    next if existing[:value] == value && existing[:constant_name] == "Event#{name}"
+
+    warnings << "Qt::QEventSymbolMap: #{symbol_name}=Event#{name}(#{value}) conflicts with existing " \
+                "#{existing[:constant_name]}(#{existing[:value]}); keeping existing #{existing[:constant_name]}"
+  end
+
+  symbol_map
+end
+
 def collect_qt_scoped_enum_constants(ast, warnings = [])
   constants_by_owner = Hash.new { |h, k| h[k] = {} }
 
@@ -1059,6 +1086,7 @@ def generate_ruby_constants(ast)
   warnings = []
   constants = collect_qt_namespace_enum_constants(ast, warnings)
   scoped_constants = collect_qt_scoped_enum_constants(ast, warnings)
+  event_symbol_map = collect_qevent_symbol_map(ast, warnings)
   emit_generation_warnings(warnings)
   lines = ['# frozen_string_literal: true', '', 'module Qt']
 
@@ -1076,6 +1104,12 @@ def generate_ruby_constants(ast)
     lines << '    },'
   end
   lines << '  }.freeze unless const_defined?(:GENERATED_SCOPED_CONSTANTS, false)'
+  lines << ''
+  lines << '  GENERATED_EVENT_TYPES = {'
+  event_symbol_map.sort.each do |symbol_name, entry|
+    lines << "    #{symbol_name.inspect} => #{entry[:constant_name]},"
+  end
+  lines << '  }.freeze unless const_defined?(:GENERATED_EVENT_TYPES, false)'
 
   lines << 'end'
   "#{lines.join("\n")}\n"
@@ -1104,6 +1138,14 @@ timed('write_ruby_constants') do
   FileUtils.mkdir_p(File.dirname(RUBY_CONSTANTS_PATH))
   File.write(RUBY_CONSTANTS_PATH, generate_ruby_constants(ast))
 end
+timed('write_ruby_event_payloads') do
+  FileUtils.mkdir_p(File.dirname(RUBY_EVENT_PAYLOADS_PATH))
+  File.write(RUBY_EVENT_PAYLOADS_PATH, generate_ruby_event_payloads(ast))
+end
+timed('write_cpp_event_payloads') do
+  FileUtils.mkdir_p(File.dirname(CPP_EVENT_PAYLOADS_PATH))
+  File.write(CPP_EVENT_PAYLOADS_PATH, generate_cpp_event_payload_extractor(ast))
+end
 timed('write_ruby_widgets') do
   FileUtils.mkdir_p(File.dirname(RUBY_WIDGETS_PATH))
   File.write(RUBY_WIDGETS_PATH, generate_ruby_widgets(effective_specs, super_qt_by_qt, wrapper_qt_classes))
@@ -1113,4 +1155,6 @@ debug_log("total=#{format('%.3fs', monotonic_now - total_start)}")
 puts "Generated #{CPP_PATH}"
 puts "Generated #{API_PATH}"
 puts "Generated #{RUBY_CONSTANTS_PATH}"
+puts "Generated #{RUBY_EVENT_PAYLOADS_PATH}"
+puts "Generated #{CPP_EVENT_PAYLOADS_PATH}"
 puts "Generated #{RUBY_WIDGETS_PATH}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qt
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Maksim Veynberg
@@ -72,6 +72,7 @@ files:
 - scripts/generate_bridge/auto_methods.rb
 - scripts/generate_bridge/core_utils.rb
 - scripts/generate_bridge/cpp_method_return_emitter.rb
+- scripts/generate_bridge/event_payloads.rb
 - scripts/generate_bridge/ffi_api.rb
 - scripts/generate_bridge/free_function_specs.rb
 - scripts/generate_bridge/spec_discovery.rb
@@ -80,7 +81,7 @@ licenses:
 - BSD-2-Clause
 metadata:
   source_code_uri: https://github.com/CyJimmy264/qt
-  changelog_uri: https://github.com/CyJimmy264/qt/releases
+  changelog_uri: https://github.com/CyJimmy264/qt/blob/master/CHANGELOG.md
   bug_tracker_uri: https://github.com/CyJimmy264/qt/issues
   rubygems_mfa_required: 'true'
 rdoc_options: []