qt 0.1.9 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50d48e8571c76d7413f893a6189b7670629bd3a80123a131bf9cc00ffe6d818e
-  data.tar.gz: bcb0081e9ebabc04175f7f041fdf8442293d08191e5ee6e2b26164d32c730942
+  metadata.gz: dcd3d0dc3ef5c1d53209f273d6b5781b335c1dd11e9d3f41ddd1b709c7a61904
+  data.tar.gz: 31374c47b19b8c121904ffa042c13910e0512879a63dde9392f69ce0d6a81004
 SHA512:
-  metadata.gz: 82bde56dd8d499bfc122923554109e6f7f92dfea399ed6fd2f821737c29cfb487b0025908409273aeb13df2ca9ed57a36eb524142a968c24a84eba43af4836b3
-  data.tar.gz: 0444cabcb5c8ce71559758e92168f0f357de967edaaf15671f5f867f7e115dc48615e49de6d4d9a3fa55c7d098da46460b810ec0ac07ff625922c724daeac575
+  metadata.gz: '091c51ec3e5869a0acea502c8487e7bbecf45bf4f45549e26e06ee5eb95462a216e03e067dfb4081675e1ea94a662c4ee39a27a4d7adb80e7f8e6347ca45ac4f'
+  data.tar.gz: 4f5f4d68d1573229567c85b8835348e6e165e96f904583ae3e3b054f950dcaf324b9b6d8b912ecc49f13332af6f9009acddf8a670460e714dbdd172150825e03

data/ext/qt_ruby_bridge/extconf.rb

@@ -60,6 +60,8 @@ runtime_hpp = File.expand_path('../../ext/qt_ruby_bridge/qt_ruby_runtime.hpp', _
 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,10 +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.
@@ -13,6 +17,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);
@@ -20,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_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/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/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/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/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.9'
+  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

@@ -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'
@@ -31,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)