qt 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50d48e8571c76d7413f893a6189b7670629bd3a80123a131bf9cc00ffe6d818e
-  data.tar.gz: bcb0081e9ebabc04175f7f041fdf8442293d08191e5ee6e2b26164d32c730942
+  metadata.gz: c0e7757f47bb17be90f64d3bcdd28ba17e5e8099a505062a7e7c3dd71aaedf37
+  data.tar.gz: cbf55606a5a16e12cb4ef47b73756a1f3ef3b65c1e500583928a44a4d28b97c4
 SHA512:
-  metadata.gz: 82bde56dd8d499bfc122923554109e6f7f92dfea399ed6fd2f821737c29cfb487b0025908409273aeb13df2ca9ed57a36eb524142a968c24a84eba43af4836b3
-  data.tar.gz: 0444cabcb5c8ce71559758e92168f0f357de967edaaf15671f5f867f7e115dc48615e49de6d4d9a3fa55c7d098da46460b810ec0ac07ff625922c724daeac575
+  metadata.gz: 1e5e470938bc069179be121de52a5e2986479a7fa8dec030d743de246fef73812729bc57ea67d4958c076e42e8d23ef703c0931e51544f206352e3ba45a3c463
+  data.tar.gz: bc3d7083a9617ad49b2b139d0948bec69257ad5991be08525de8228e87aa3457bdd9d4d2745b399bf20f0266143428565e3fb5d88e039255687eb90b38c7efe9

data/ext/qt_ruby_bridge/extconf.rb

@@ -60,6 +60,7 @@ 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
 ].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,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/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.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/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

@@ -300,7 +300,8 @@ def discover_target_qt_classes(ast, scope)
     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
+    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(

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}"
@@ -1173,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'
 
@@ -1181,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],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qt
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  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