qt 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0e7757f47bb17be90f64d3bcdd28ba17e5e8099a505062a7e7c3dd71aaedf37
-  data.tar.gz: cbf55606a5a16e12cb4ef47b73756a1f3ef3b65c1e500583928a44a4d28b97c4
+  metadata.gz: dcd3d0dc3ef5c1d53209f273d6b5781b335c1dd11e9d3f41ddd1b709c7a61904
+  data.tar.gz: 31374c47b19b8c121904ffa042c13910e0512879a63dde9392f69ce0d6a81004
 SHA512:
-  metadata.gz: 1e5e470938bc069179be121de52a5e2986479a7fa8dec030d743de246fef73812729bc57ea67d4958c076e42e8d23ef703c0931e51544f206352e3ba45a3c463
-  data.tar.gz: bc3d7083a9617ad49b2b139d0948bec69257ad5991be08525de8228e87aa3457bdd9d4d2745b399bf20f0266143428565e3fb5d88e039255687eb90b38c7efe9
+  metadata.gz: '091c51ec3e5869a0acea502c8487e7bbecf45bf4f45549e26e06ee5eb95462a216e03e067dfb4081675e1ea94a662c4ee39a27a4d7adb80e7f8e6347ca45ac4f'
+  data.tar.gz: 4f5f4d68d1573229567c85b8835348e6e165e96f904583ae3e3b054f950dcaf324b9b6d8b912ecc49f13332af6f9009acddf8a670460e714dbdd172150825e03

data/ext/qt_ruby_bridge/extconf.rb

@@ -61,6 +61,7 @@ runtime_cpp_files = %w[
   runtime_events.cpp
   runtime_signals.cpp
   runtime_value_types.cpp
+  runtime_virtual_methods.cpp
 ].map { |name| File.expand_path("../../ext/qt_ruby_bridge/#{name}", __dir__) }
 
 unless File.exist?(generated_cpp)

data/ext/qt_ruby_bridge/qt_ruby_runtime.hpp

@@ -1,12 +1,14 @@
 #pragma once
 
 #include <QApplication>
+#include <QByteArray>
 #include <QList>
 #include <QVariant>
 
 namespace QtRubyRuntime {
 using EventCallback = int (*)(void*, int, const char*);
 using SignalCallback = void (*)(void*, int, const char*);
+using VirtualMethodCallback = void* (*)(void*, int, const char*);
 
 // Creates/owns the singleton QApplication used by the Ruby runtime bridge.
 // The implementation records the creating thread as GUI thread for shutdown checks.
@@ -26,4 +28,10 @@ void unwatch_qobject_event(void* object_handle, int event_type);
 void set_signal_callback(void* callback_ptr);
 int qobject_connect_signal(void* object_handle, const char* signal_name);
 int qobject_disconnect_signal(void* object_handle, const char* signal_name);
+
+void set_virtual_method_callback(void* callback_ptr);
+void set_virtual_dispatch_enabled(void* object_handle, int enabled);
+int virtual_dispatch_enabled(void* object_handle);
+QByteArray dispatch_virtual_method(const void* object_handle, int method_id, const QByteArray& arguments);
+bool ruby_virtual_method_active(const void* object_handle, int method_id);
 }  // namespace QtRubyRuntime

data/ext/qt_ruby_bridge/runtime_virtual_methods.cpp

@@ -0,0 +1,78 @@
+#include "qt_ruby_runtime.hpp"
+
+#include <vector>
+#include <unordered_set>
+#include <mutex>
+
+namespace QtRubyRuntime {
+namespace {
+struct ActiveVirtualMethod {
+  const void* object_handle;
+  int method_id;
+};
+
+VirtualMethodCallback& virtual_method_callback_ref() {
+  static VirtualMethodCallback callback = nullptr;
+  return callback;
+}
+
+std::vector<ActiveVirtualMethod>& active_virtual_methods() {
+  thread_local std::vector<ActiveVirtualMethod> active;
+  return active;
+}
+
+std::unordered_set<const void*>& virtual_dispatch_objects() {
+  static std::unordered_set<const void*> objects;
+  return objects;
+}
+
+std::mutex& virtual_dispatch_mutex() {
+  static std::mutex mutex;
+  return mutex;
+}
+}  // namespace
+}  // namespace QtRubyRuntime
+
+void QtRubyRuntime::set_virtual_method_callback(void* callback_ptr) {
+  virtual_method_callback_ref() = reinterpret_cast<VirtualMethodCallback>(callback_ptr);
+}
+
+void QtRubyRuntime::set_virtual_dispatch_enabled(void* object_handle, int enabled) {
+  if (!object_handle) {
+    return;
+  }
+  std::lock_guard<std::mutex> lock(virtual_dispatch_mutex());
+  if (enabled != 0) {
+    virtual_dispatch_objects().insert(object_handle);
+  } else {
+    virtual_dispatch_objects().erase(object_handle);
+  }
+}
+
+int QtRubyRuntime::virtual_dispatch_enabled(void* object_handle) {
+  std::lock_guard<std::mutex> lock(virtual_dispatch_mutex());
+  return virtual_dispatch_objects().find(object_handle) != virtual_dispatch_objects().end();
+}
+
+QByteArray QtRubyRuntime::dispatch_virtual_method(const void* object_handle, int method_id, const QByteArray& arguments) {
+  VirtualMethodCallback callback = virtual_method_callback_ref();
+  if (!callback) {
+    return {};
+  }
+
+  auto& active = active_virtual_methods();
+  active.push_back({object_handle, method_id});
+  void* response = callback(const_cast<void*>(object_handle), method_id, arguments.constData());
+  active.pop_back();
+  return response ? QByteArray(static_cast<const char*>(response)) : QByteArray();
+}
+
+bool QtRubyRuntime::ruby_virtual_method_active(const void* object_handle, int method_id) {
+  const auto& active = active_virtual_methods();
+  for (auto it = active.rbegin(); it != active.rend(); ++it) {
+    if (it->object_handle == object_handle && it->method_id == method_id) {
+      return true;
+    }
+  }
+  return false;
+}

data/lib/qt/application_lifecycle.rb

@@ -23,7 +23,7 @@ module Qt
 
     def exec
       @windows.each(&:show)
-      Native.qapplication_exec(@handle)
+      Qt::VirtualMethodRuntime.after_native_call(Native.qapplication_exec(@handle))
     ensure
       dispose
     end

data/lib/qt/generated_overload_runtime.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Qt
+  module GeneratedOverloadRuntime
+    OMITTED = Object.new.freeze
+  end
+end

data/lib/qt/object_wrapper.rb

@@ -172,6 +172,7 @@ module Qt
         destroy_hook_addresses.delete(address)
         Qt::EventRuntime.clear_signal_registrations_for_address(address)
         invalidate_cached_wrapper(address, wrapper)
+        wrapper.instance_variable_set(:@handle, nil) if wrapper.handle&.address == address
       end
     rescue StandardError
       destroy_hook_addresses.delete(address)

data/lib/qt/version.rb

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

data/lib/qt/virtual_method_runtime.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'weakref'
+
+module Qt
+  # Dispatches generated C++ virtual overrides to methods defined by Ruby subclasses.
+  module VirtualMethodRuntime
+    module_function
+
+    def install!(descriptors)
+      @descriptors = descriptors.to_h { |descriptor| [descriptor.fetch(:id), symbolize_keys(descriptor)] }
+      return if @callback
+
+      @callback = FFI::Function.new(:pointer, %i[pointer int string]) do |object_handle, method_id, payload|
+        dispatch(object_handle, method_id, payload)
+      end
+    end
+
+    def ensure_installed!
+      return if @native_installed
+
+      Native.define_bridge_wrappers!
+      Native.set_virtual_method_callback(@callback)
+      @native_installed = true
+    end
+
+    def attach(wrapper)
+      ensure_installed!
+      enabled = @descriptors&.values&.any? { |descriptor| overridden_method_name(wrapper, descriptor) }
+      handle = wrapper.handle
+      Native.set_virtual_dispatch_enabled(handle, enabled ? 1 : 0)
+      if enabled
+        wrapper_cache[handle.address] = WeakRef.new(wrapper)
+      else
+        wrapper_cache.delete(handle.address)
+      end
+      wrapper
+    end
+
+    def dispatch(object_handle, method_id, payload)
+      descriptor = @descriptors&.[](method_id)
+      return callback_response(handled: false) unless descriptor
+
+      object_address = pointer_address(object_handle)
+      return callback_response(handled: false) if object_address.zero?
+
+      object_pointer = FFI::Pointer.new(object_address)
+      wrapper = ObjectWrapper.cached_wrapper_for(object_pointer) || cached_wrapper_for(object_address)
+      return callback_response(handled: false) unless wrapper
+
+      ruby_method = overridden_method_name(wrapper, descriptor)
+      return callback_response(handled: false) unless ruby_method
+
+      encoded_args = payload.nil? || payload.empty? ? [] : JSON.parse(StringCodec.from_qt_text(payload))
+      args = descriptor.fetch(:args).zip(encoded_args).map do |arg_descriptor, value|
+        decode_argument(arg_descriptor, value)
+      end
+      value = wrapper.__send__(ruby_method, *args)
+      callback_response(handled: true, value: encode_return(descriptor.fetch(:return), value))
+    rescue Exception => error # FFI callbacks must not unwind a Ruby exception through C++.
+      (@callback_errors ||= {})[Thread.current.object_id] = error
+      callback_response(handled: false)
+    end
+
+    def raise_pending_error!
+      error = @callback_errors&.delete(Thread.current.object_id)
+      raise error if error
+    end
+
+    def after_native_call(result)
+      raise_pending_error!
+      result
+    end
+
+    def decode_argument(descriptor, value)
+      case descriptor.fetch(:kind)
+      when :integer then Integer(value)
+      when :boolean then value == true
+      when :string then value
+      when :pointer, :value then wrap_borrowed_pointer(value, descriptor[:qt_class])
+      else raise ArgumentError, "unsupported virtual argument kind: #{descriptor[:kind].inspect}"
+      end
+    end
+
+    def wrap_borrowed_pointer(value, qt_class)
+      address = value.nil? ? 0 : Integer(value)
+      return nil if address.zero?
+
+      pointer = FFI::Pointer.new(address)
+      klass = Qt.const_get(qt_class, false)
+      return ObjectWrapper.wrap(pointer, qt_class) if klass <= QObject
+
+      wrapper = klass.allocate
+      wrapper.instance_variable_set(:@handle, pointer)
+      wrapper
+    end
+
+    def encode_return(descriptor, value)
+      case descriptor.fetch(:kind)
+      when :void then nil
+      when :integer
+        Integer(value)
+      when :boolean
+        value == true
+      when :string
+        value.nil? ? '' : String(value)
+      when :pointer, :value
+        return nil if value.nil?
+        raise TypeError, 'Qt pointer return must be a wrapper with a handle' unless value.respond_to?(:handle)
+
+        value.handle.address.to_s
+      else raise ArgumentError, "unsupported virtual return kind: #{descriptor[:kind].inspect}"
+      end
+    end
+
+    def callback_response(handled:, value: nil)
+      response = JSON.generate(handled: handled, value: value)
+      buffer = FFI::MemoryPointer.from_string(response)
+      (@callback_buffers ||= {})[Thread.current.object_id] = buffer
+      buffer
+    end
+
+    def overridden_method_name(wrapper, descriptor)
+      wrapper_class = Qt.const_get(descriptor.fetch(:wrapper_class), false)
+      return nil unless wrapper.class.ancestors.include?(wrapper_class)
+
+      candidates = [descriptor.fetch(:ruby_name).to_sym, descriptor.fetch(:snake_name).to_sym].uniq
+      wrapper.class.ancestors.take_while { |ancestor| ancestor != wrapper_class }.each do |ancestor|
+        candidates.each do |candidate|
+          methods = ancestor.instance_methods(false) + ancestor.private_instance_methods(false)
+          return candidate if methods.include?(candidate)
+        end
+      end
+      nil
+    end
+
+    def wrapper_cache
+      @wrapper_cache ||= {}
+    end
+
+    def cached_wrapper_for(address)
+      reference = wrapper_cache[address]
+      reference&.__getobj__
+    rescue WeakRef::RefError
+      wrapper_cache.delete(address)
+      nil
+    end
+
+    def pointer_address(pointer)
+      return 0 if pointer.nil?
+      return pointer.address if pointer.respond_to?(:address)
+
+      Integer(pointer)
+    end
+
+    def symbolize_keys(value)
+      case value
+      when Hash then value.to_h { |key, nested| [key.to_sym, symbolize_keys(nested)] }
+      when Array then value.map { |nested| symbolize_keys(nested) }
+      else value
+      end
+    end
+  end
+end

data/lib/qt.rb

@@ -32,11 +32,14 @@ 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/generated_overload_runtime'
+require_relative 'qt/virtual_method_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::VirtualMethodRuntime.install!(Qt::GENERATED_VIRTUAL_METHODS)
 Qt::GeneratedSetterAliasesRuntime.apply!(Qt)
 Qt::GeneratedSingletonForwardersRuntime.apply!(Qt)
 Qt::ObjectWrapper.install_constructor_cache_hooks!

data/scripts/generate_bridge/ast_introspection.rb

@@ -55,7 +55,10 @@ class AstClassMemberRecorder
     return false unless inner['kind'] == 'CXXMethodDecl' && inner['name']
 
     access = inner['access'] || current_access
-    @methods_by_class[@class_name][inner['name']] << inner.merge('__effective_access' => access)
+    @methods_by_class[@class_name][inner['name']] << inner.merge(
+      '__effective_access' => access,
+      '__owner_class' => @class_name
+    )
     true
   end
 
@@ -172,7 +175,8 @@ def ast_class_index_constructor_collections
   {
     ctors_by_class: Hash.new { |h, k| h[k] = [] },
     ctor_decls_by_class: Hash.new { |h, k| h[k] = [] },
-    abstract_by_class: Hash.new(false)
+    abstract_by_class: Hash.new(false),
+    final_by_class: Hash.new(false)
   }
 end
 
@@ -189,6 +193,8 @@ def ast_index_track_record_decl(node, data)
   return if class_name.nil? || class_name.empty?
 
   data[:abstract_by_class][class_name] ||= node.dig('definitionData', 'isAbstract') == true
+  data[:final_by_class][class_name] ||= node['final'] == true ||
+                                       Array(node['inner']).any? { |child| child['kind'] == 'FinalAttr' }
   ast_record_base_classes(node, class_name, data[:bases_by_class])
   method_count, ctor_count = ast_record_class_members(
     node, class_name, data[:methods_by_class], data[:ctors_by_class], data[:ctor_decls_by_class]
@@ -202,7 +208,14 @@ def finalize_ast_class_index!(data)
   data[:ctors_by_class].each_value(&:uniq!)
   debug_log("ast_class_index classes=#{data[:methods_by_class].length} method_decls=#{data[:method_decl_count]}")
   debug_log("ast_class_index ctor_decls=#{data[:ctor_decl_count]}")
-  data.slice(:methods_by_class, :bases_by_class, :ctors_by_class, :ctor_decls_by_class, :abstract_by_class)
+  data.slice(
+    :methods_by_class,
+    :bases_by_class,
+    :ctors_by_class,
+    :ctor_decls_by_class,
+    :abstract_by_class,
+    :final_by_class
+  )
 end
 
 def ast_class_index(ast)