wxruby3 1.7.0 → 1.8.0

data/ext/wxruby3/include/wxruby-GCTracking.h

@@ -0,0 +1,262 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+#include <wx/thread.h>
+
+#include <string>
+#include <unordered_map>
+
+typedef std::unordered_map<void*, VALUE>  TGCTrackingValueMap;
+typedef void (* TGCMarkerFunction)(const TGCTrackingValueMap&);
+
+typedef struct
+{
+    TGCMarkerFunction   marker_ {};
+    TGCTrackingValueMap values_ {};
+    // false by default causing the marker function to be always called
+    // can become true if actual values are added/removed in which case
+    // the marker will only be called if there any values tracked
+    bool                has_data_ {true};
+} TGCTrackingItem;
+
+typedef std::unordered_map<std::string, TGCTrackingItem>  TGCTrackingTable;
+
+static void __wxruby_mark_SWIG_objects(const TGCTrackingValueMap& values);
+
+class SGCTracking
+{
+private:
+  static const std::string SWIG_TRACKING;
+
+  TGCTrackingItem& tracking_item(const std::string& cat) { return this->map_[cat]; }
+  TGCTrackingValueMap& tracking_map(const std::string& cat) { return this->map_[cat].values_; }
+
+  wxCriticalSection lock_ {};
+
+  TGCTrackingTable map_ {};
+
+public:
+  SGCTracking()
+  {
+    // create a tracking entry for SWIG objects with the appropriate marker
+    this->map_[SWIG_TRACKING].marker_ = __wxruby_mark_SWIG_objects;
+    this->map_[SWIG_TRACKING].has_data_ = true;
+  }
+
+  void add_category(std::string cat, TGCMarkerFunction marker, bool has_data = false)
+  {
+    wxCriticalSectionLocker guard(this->lock_);
+    this->map_[cat].marker_ = marker;
+    this->map_[cat].has_data_ = has_data;
+  }
+
+  void add_tracking(const std::string& cat, void* ptr, VALUE object)
+  {
+    wxCriticalSectionLocker guard(this->lock_);
+    auto& ti = tracking_item(cat);
+    ti.values_[ptr] = object;
+    if (!ti.has_data_) ti.has_data_ = true;
+  }
+  void remove_tracking(const std::string& cat, void* ptr)
+  {
+    wxCriticalSectionLocker guard(this->lock_);
+    auto& ti = tracking_item(cat);
+    ti.values_.erase(ptr);
+  }
+  VALUE find_tracking(const std::string& cat, void* ptr)
+  {
+    wxCriticalSectionLocker guard(this->lock_);
+    auto& map = tracking_map(cat);
+    auto it = map.find(ptr);
+    return it == map.end() ? Qnil : it->second;
+  }
+
+  void swig_add_tracking(void* ptr, VALUE object)
+  {
+    add_tracking(SWIG_TRACKING, ptr, object);
+  }
+  void swig_remove_tracking(void* ptr)
+  {
+    remove_tracking(SWIG_TRACKING, ptr);
+  }
+  VALUE swig_find_tracking(void* ptr)
+  {
+    return find_tracking(SWIG_TRACKING, ptr);
+  }
+
+  void run_markers()
+  {
+    wxCriticalSectionLocker guard(this->lock_);
+    for (const auto& gti : this->map_)
+    {
+      if (!gti.second.has_data_ || !gti.second.values_.empty())
+        (*gti.second.marker_)(gti.second.values_);
+    }
+  }
+};
+
+const std::string SGCTracking::SWIG_TRACKING = {"SWIG_TRACKING"};
+
+static SGCTracking __g_GCTracking {};
+
+WXRUBY_TRACE_GUARD(WxRubyTraceGCTrackSWIG, "GC_TRACK_SWIG")
+WXRUBY_TRACE_GUARD(WxRubyTraceGCTrackRegistry, "GC_TRACK_REGISTRY")
+
+// When ruby's garbage collection runs, if the app is still active, it
+// the marking phase on currently known SWIG objects which calls this
+// function on each to preserve still active Wx::Windows, and also
+// pending Wx::Events which have been queued from the Ruby side (the
+// only sort of events that will be in the tracking hash).
+static void __wxruby_mark_SWIG_objects(const TGCTrackingValueMap& values)
+{
+  for (const auto& vp : values)
+  {
+    // Check if it's a valid object (sometimes SWIG doesn't return what we're
+    // expecting), a descendant of Wx::Window or Wx::Event; if so, mark it.
+    if ( TYPE(vp.second) == T_DATA )
+    {
+      if ( rb_obj_is_kind_of(vp.second, wxRuby_GetWindowClass()) )
+      {
+        rb_gc_mark(vp.second);
+      }
+      else if (rb_obj_is_kind_of(vp.second, wxRuby_GetDefaultEventClass()) )
+      {
+        rb_gc_mark(vp.second);
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Add a tracking from ptr -> object
+WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object)
+{
+  WXRUBY_TRACE_IF(WxRubyTraceGCTrackSWIG, 2)
+    WXRUBY_TRACE("> wxRuby_AddTracking" << std::flush <<
+                   "(" << ptr << ":{"
+                       << rb_class2name(CLASS_OF(object))
+                       << "}, " << object << ")")
+  WXRUBY_TRACE_END
+
+  // Check if an 'old' tracking registry exists.
+  VALUE old_obj = __g_GCTracking.swig_find_tracking(ptr);
+  if (!RB_NIL_P(old_obj))
+  {
+    // This can happen if the C++ referenced by a Ruby object is managed by
+    // a wxWidgets object and deleted without unlinking the Ruby object.
+    // In these cases we unlink the previously linked Ruby object here
+    // (if not the same Ruby object which should not be possible).
+    // This will prevent SIGSEGV when attempting to call anything for
+    // these objects but instead cause more informative exceptions.
+    if (old_obj != object)
+    {
+      DATA_PTR(old_obj) = 0;
+    }
+
+  }
+  __g_GCTracking.swig_add_tracking(ptr, object);
+}
+
+// Return the ruby object for ptr
+WXRUBY_EXPORT VALUE wxRuby_FindTracking(void* ptr)
+{
+  return __g_GCTracking.swig_find_tracking(ptr);
+}
+
+// Remove the tracking for ptr
+WXRUBY_EXPORT void wxRuby_RemoveTracking(void* ptr)
+{
+  WXRUBY_TRACE_IF(WxRubyTraceGCTrackSWIG, 2)
+    WXRUBY_TRACE("< wxRuby_RemoveTracking(" << ptr << ") -> " << __g_GCTracking.swig_find_tracking(ptr))
+  WXRUBY_TRACE_END
+
+  __g_GCTracking.swig_remove_tracking(ptr);
+}
+
+WXRUBY_EXPORT void wxRuby_UnlinkObject(void* ptr)
+{
+  WXRUBY_TRACE_IF(WxRubyTraceGCTrackSWIG, 2)
+    WXRUBY_TRACE("< wxRuby_UnlinkObject(" << ptr << ") -> " << __g_GCTracking.swig_find_tracking(ptr))
+  WXRUBY_TRACE_END
+
+  VALUE object = __g_GCTracking.swig_find_tracking(ptr);
+  if (object != Qnil)
+  {
+    DATA_PTR(object) = 0;
+  }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+WXRUBY_EXPORT void wxRuby_MarkTracked()
+{
+  __g_GCTracking.run_markers();
+}
+
+WXRUBY_EXPORT void wxRuby_RegisterTrackingCategory(std::string category, TGCMarkerFunction marker, bool has_data)
+{
+  WXRUBY_TRACE_IF(WxRubyTraceGCTrackRegistry, 2)
+    WXRUBY_TRACE("< wxRuby_RegisterTrackingCategory(" << category.c_str() << ", " << marker << ")")
+  WXRUBY_TRACE_END
+
+  // create a tracking entry
+  __g_GCTracking.add_category(category, marker, has_data);
+}
+
+WXRUBY_EXPORT void wxRuby_RegisterCategoryValue(const std::string &category, void *ptr, VALUE object)
+{
+  WXRUBY_TRACE_IF(WxRubyTraceGCTrackRegistry, 2)
+    WXRUBY_TRACE("> wxRuby_RegisterCategoryValue" << std::flush <<
+                   "(" << category.c_str() << ", "
+                       << ptr << ":{"
+                       << rb_class2name(CLASS_OF(object))
+                       << "}, " << object << ")")
+  WXRUBY_TRACE_END
+
+  // Check if an 'old' tracking registry exists (should never happen but still
+  // let's be paranoid).
+  VALUE old_obj = __g_GCTracking.find_tracking(category, ptr);
+  if (!RB_NIL_P(old_obj))
+  {
+    WXRUBY_TRACE_IF(WxRubyTraceGCTrackRegistry, 2)
+      WXRUBY_TRACE("> wxRuby_RegisterCategoryValue : found stale VALUE " << old_obj)
+    WXRUBY_TRACE_END
+
+    if (old_obj != object)
+    {
+      DATA_PTR(old_obj) = 0;
+    }
+
+  }
+  __g_GCTracking.add_tracking(category, ptr, object);
+}
+
+WXRUBY_EXPORT void wxRuby_UnregisterCategoryValue(const std::string &category, void *ptr)
+{
+  WXRUBY_TRACE_IF(WxRubyTraceGCTrackRegistry, 2)
+    WXRUBY_TRACE("> wxRuby_UnregisterCategoryValue" << std::flush <<
+                   "(" << category.c_str() << ", " << ptr << ")")
+  WXRUBY_TRACE_END
+
+  __g_GCTracking.remove_tracking(category, ptr);
+}
+
+WXRUBY_EXPORT VALUE wxRuby_FindCategoryValue(const std::string &category, void *ptr)
+{
+  return __g_GCTracking.find_tracking(category, ptr);
+}
+
+WXRUBY_EXPORT void wxRuby_UnlinkCategoryValue(const std::string &category, void* ptr)
+{
+  VALUE object = __g_GCTracking.find_tracking(category, ptr);
+  if (object != Qnil)
+  {
+    DATA_PTR(object) = 0;
+  }
+}

data/ext/wxruby3/include/wxruby-MBConv.h

@@ -0,0 +1,190 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+/*
+ * WxRuby3 Wx::MBConv classes
+ */
+
+#include <wx/strconv.h>
+#include <wx/convauto.h>
+#include <memory>
+
+static VALUE cWxMBConv;
+
+// instance variable for MBConv classes
+static const char * __iv_cMBConv_conv_id = "@conv_id";
+
+static VALUE wx_MBConv_initialize(int argc, VALUE *argv, VALUE self)
+{
+  static const std::string classname {"Wx::MBConv"};
+  if (classname == rb_obj_classname(self))
+  {
+    rb_raise(rb_eNameError,"accessing abstract class or protected constructor");
+    return Qnil;
+  }
+  if (argc > 0)
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc);
+    return Qnil;
+  }
+  return self;
+}
+
+// instance variable for derived Wx::CSConv  and Wx::ConvAuto classes
+static const char * __iv_csconv_encoding = "@encoding";   // Wx::FontEncoding enum or string
+
+static VALUE wx_CSConv_initialize(int argc, VALUE *argv, VALUE self)
+{
+  if (argc != 1)
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc);
+    return Qnil;
+  }
+  if (!wxRuby_IsEnumValue("FontEncoding", argv[0]) && TYPE(argv[0]) != T_STRING)
+  {
+    VALUE msg = rb_inspect(argv[0]);
+    rb_raise(rb_eTypeError, "expected Wx::FontEncoding or String for 1 but got %s", StringValuePtr(msg));
+    return Qnil;
+  }
+  rb_iv_set(self, __iv_csconv_encoding, argv[0]);
+  return self;
+}
+
+static VALUE wx_ConvAuto_initialize(int argc, VALUE *argv, VALUE self)
+{
+  if (argc != 1)
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc);
+    return Qnil;
+  }
+  if (!wxRuby_IsEnumValue("FontEncoding", argv[0]))
+  {
+    VALUE msg = rb_inspect(argv[0]);
+    rb_raise(rb_eTypeError, "expected Wx::FontEncoding for 1 but got %s", StringValuePtr(msg));
+    return Qnil;
+  }
+  rb_iv_set(self, __iv_csconv_encoding, argv[0]);
+  return self;
+}
+
+static VALUE wxConvAuto_disable_fallback_encoding(int argc, VALUE* argv, VALUE self)
+{
+  if (argc > 0)
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc);
+    return Qnil;
+  }
+  wxConvAuto::DisableFallbackEncoding();
+  return Qnil;
+}
+
+static VALUE wxConvAuto_get_fallback_encoding(int argc, VALUE* argv, VALUE self)
+{
+  if (argc > 0)
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc);
+    return Qnil;
+  }
+  wxFontEncoding enc = wxConvAuto::GetFallbackEncoding();
+  return wxRuby_GetEnumValueObject("FontEncoding", static_cast<int>(enc));
+}
+
+static VALUE wxConvAuto_set_fallback_encoding(int argc, VALUE* argv, VALUE self)
+{
+  if (argc != 1)
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc);
+    return Qnil;
+  }
+  int eval;
+  if (!wxRuby_GetEnumValue("FontEncoding", argv[0], eval))
+  {
+    VALUE msg = rb_inspect(argv[0]);
+    rb_raise(rb_eTypeError, "expected Wx::FontEncoding for 1 but got %s", StringValuePtr(msg));
+    return Qnil;
+  }
+  wxConvAuto::SetFallbackEncoding(static_cast<wxFontEncoding> (eval));
+  return Qnil;
+}
+
+static WxRuby_ID mbconv_cs_id("CSConv");
+static WxRuby_ID mbconv_auto_id("ConvAuto");
+static WxRuby_ID mbconv_utf16_id("ConvUTF16");
+static WxRuby_ID mbconv_utf32_id("ConvUTF32");
+static WxRuby_ID mbconv_utf7_id("ConvUTF7");
+static WxRuby_ID mbconv_utf8_id("ConvUTF8");
+
+static void wx_setup_MBConv()
+{
+  cWxMBConv = rb_define_class_under(mWxCore, "MBConv", rb_cObject);
+  rb_define_method(cWxMBConv, "initialize", VALUEFUNC(wx_MBConv_initialize), -1);
+
+  VALUE cWxCSConv = rb_define_class_under(mWxCore, "CSConv", cWxMBConv);
+  rb_iv_set(cWxCSConv, __iv_cMBConv_conv_id, ID2SYM(mbconv_cs_id()));
+  rb_define_method(cWxCSConv, "initialize", VALUEFUNC(wx_CSConv_initialize), -1);
+
+  VALUE cWxConvAuto = rb_define_class_under(mWxCore, "ConvAuto", cWxMBConv);
+  rb_iv_set(cWxCSConv, __iv_cMBConv_conv_id, ID2SYM(mbconv_auto_id()));
+  rb_define_method(cWxConvAuto, "initialize", VALUEFUNC(wx_ConvAuto_initialize), -1);
+  rb_define_module_function(cWxConvAuto, "disable_fallback_encoding", VALUEFUNC(wxConvAuto_disable_fallback_encoding), -1);
+  rb_define_module_function(cWxConvAuto, "disable_get_encoding", VALUEFUNC(wxConvAuto_get_fallback_encoding), -1);
+  rb_define_module_function(cWxConvAuto, "disable_set_encoding", VALUEFUNC(wxConvAuto_set_fallback_encoding), -1);
+
+  VALUE cWxMBConvUTF16 = rb_define_class_under(mWxCore, "MBConvUTF16", cWxMBConv);
+  rb_iv_set(cWxMBConvUTF16, __iv_cMBConv_conv_id, ID2SYM(mbconv_utf16_id()));
+
+  VALUE cWxMBConvUTF32 = rb_define_class_under(mWxCore, "MBConvUTF32", cWxMBConv);
+  rb_iv_set(cWxMBConvUTF32, __iv_cMBConv_conv_id, ID2SYM(mbconv_utf32_id()));
+
+  VALUE cWxMBConvUTF7 = rb_define_class_under(mWxCore, "MBConvUTF7", cWxMBConv);
+  rb_iv_set(cWxMBConvUTF7, __iv_cMBConv_conv_id, ID2SYM(mbconv_utf7_id()));
+
+  VALUE cWxMBConvUTF8 = rb_define_class_under(mWxCore, "MBConvUTF8", cWxMBConv);
+  rb_iv_set(cWxMBConvUTF8, __iv_cMBConv_conv_id, ID2SYM(mbconv_utf8_id()));
+}
+
+WXRB_EXPORT_FLAG std::unique_ptr<wxMBConv> wxRuby_MBConv2wxMBConv(VALUE rb_val)
+{
+  if (rb_obj_is_kind_of(rb_val, cWxMBConv))
+  {
+    // get id for derived MBConv class
+    ID mbconv_id = SYM2ID(rb_iv_get(CLASS_OF(rb_val), __iv_cMBConv_conv_id));
+    if (mbconv_id == mbconv_cs_id())
+    {
+      VALUE encoding = rb_iv_get(rb_val, __iv_csconv_encoding);
+      if (TYPE(encoding) == T_STRING)
+        return std::make_unique<wxCSConv> (RSTR_TO_WXSTR(encoding));
+      else
+      {
+        int enc_val;
+        wxRuby_GetEnumValue("FontEncoding", encoding, enc_val);
+        return std::make_unique<wxCSConv> (static_cast<wxFontEncoding> (enc_val));
+      }
+    }
+    else if (mbconv_id == mbconv_auto_id())
+    {
+      VALUE encoding = rb_iv_get(rb_val, __iv_csconv_encoding);
+      int enc_val;
+      wxRuby_GetEnumValue("FontEncoding", encoding, enc_val);
+      return std::make_unique<wxConvAuto> (static_cast<wxFontEncoding> (enc_val));
+    }
+    else if (mbconv_id == mbconv_utf16_id())
+    {
+      return std::make_unique<wxMBConvUTF16> ();
+    }
+    else if (mbconv_id == mbconv_utf32_id())
+    {
+      return std::make_unique<wxMBConvUTF32> ();
+    }
+    else if (mbconv_id == mbconv_utf7_id())
+    {
+      return std::make_unique<wxMBConvUTF7> ();
+    }
+    else if (mbconv_id == mbconv_utf8_id())
+    {
+      return std::make_unique<wxMBConvUTF8> ();
+    }
+  }
+  return {};
+}

data/ext/wxruby3/include/wxruby-SharedEventHandler.h

@@ -0,0 +1,183 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+/*
+ * WxRuby3 SharedEvtHandler class
+ */
+
+#ifndef _WXRUBY_SHARED_EVTHANDLER_H
+#define _WXRUBY_SHARED_EVTHANDLER_H
+
+#include <wx/object.h>
+#include <wx/event.h>
+
+class WxRubySharedEvtHandler
+{
+public:
+  WxRubySharedEvtHandler(wxEvtHandler* evt_handler)
+    : evt_handler_(evt_handler) {}
+  ~WxRubySharedEvtHandler() = default;
+
+  wxEvtHandler* get_evt_handler() { return this->evt_handler_; }
+
+  VALUE get_rb_shared_evt_handler() { return this->rb_shared_evt_handler_; }
+  void set_rb_shared_evt_handler(VALUE h) { this->rb_shared_evt_handler_ = h; }
+
+  WxRubySharedEvtHandler* clone()
+  {
+    if (this->evt_handler_)
+    {
+	  WxRubySharedEvtHandler* clone_ = new WxRubySharedEvtHandler(this->evt_handler_);
+	  return clone_;
+    }
+    return nullptr;
+  }
+
+private:
+  wxEvtHandler* evt_handler_ {};
+  VALUE rb_shared_evt_handler_ {Qnil};
+};
+
+// WxRubySharedEvtHandler wrapper class definition and helper functions
+static size_t __WxRubySharedEvtHandler_size(const void* data)
+{
+  return 0;
+}
+
+static void __WxRubySharedEvtHandler_free(void* data)
+{
+  if (data)
+    delete (WxRubySharedEvtHandler*)data;
+}
+
+#include <ruby/version.h>
+
+static const rb_data_type_t __WxRubySharedEvtHandler_type = {
+  "TreeItemId",
+#if RUBY_API_VERSION_MAJOR >= 3
+  { NULL, __WxRubySharedEvtHandler_free, __WxRubySharedEvtHandler_size, 0, {}},
+#else
+  { NULL, __WxRubySharedEvtHandler_free, __WxRubySharedEvtHandler_size, {}},
+#endif
+  NULL, NULL, RUBY_TYPED_FROZEN_SHAREABLE
+};
+
+VALUE cWxRubySharedEvtHandler;
+
+static VALUE WxRuby_get_EvtHandlerClass()
+{
+  static VALUE cEvtHandler = Qnil;
+  if (RB_NIL_P(cEvtHandler))
+  {
+    cEvtHandler = rb_const_get(wxRuby_Core(), rb_intern("EvtHandler"));
+  }
+  return cEvtHandler;
+}
+
+static VALUE WxRuby_MakeSharedEvtHandler(wxEvtHandler* wxeh)
+{
+  if (wxeh)
+  {
+    // create new shared handler
+    WxRubySharedEvtHandler* seh = new WxRubySharedEvtHandler(wxeh);
+    // create Ruby wrapper object
+    VALUE rb_shared_eh =TypedData_Wrap_Struct(cWxRubySharedEvtHandler,
+                                              &__WxRubySharedEvtHandler_type,
+                                              seh);
+    rb_shared_eh = rb_obj_freeze(rb_shared_eh);
+    seh->set_rb_shared_evt_handler(rb_shared_eh);
+    return rb_shared_eh;
+  }
+
+  return Qnil;
+}
+
+static wxEvtHandler* WxRuby_GetSharedEvtHandler(VALUE rb_shared_eh)
+{
+  if (rb_typeddata_is_kind_of(rb_shared_eh, &__WxRubySharedEvtHandler_type) == 1)
+  {
+    WxRubySharedEvtHandler* shared_eh = (WxRubySharedEvtHandler*)RTYPEDDATA_DATA(rb_shared_eh);
+    if (shared_eh)
+    {
+      wxEvtHandler* wxeh = shared_eh->get_evt_handler();
+      VALUE rb_eh = wxRuby_FindTracking(wxeh);
+      if (rb_obj_is_kind_of(rb_eh, WxRuby_get_EvtHandlerClass()))
+        return wxeh;
+    }
+  }
+  return nullptr;
+}
+
+static VALUE WxRubySharedEvtHandler_clone(VALUE self)
+{
+  WxRubySharedEvtHandler* shared_eh = (WxRubySharedEvtHandler*)RTYPEDDATA_DATA(self);
+  // create new Ruby SharedEvtHandler wrapper object with cloned WxRubySharedEvtHandler
+  VALUE clone = TypedData_Wrap_Struct(cWxRubySharedEvtHandler,
+                                      &__WxRubySharedEvtHandler_type,
+                                      shared_eh->clone());
+  return rb_obj_freeze(clone);
+}
+
+static VALUE WxRubySharedEvtHandler_queue_event(int argc, VALUE* argv, VALUE self)
+{
+  // check argument count
+  if (argc != 1)
+  {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    return Qnil;
+  }
+  // dereference shared event handler
+  wxEvtHandler* wxeh = WxRuby_GetSharedEvtHandler(self);
+  if (wxeh)
+  {
+    // get C++ event
+    wxEvent* wxevt = (wxEvent*)DATA_PTR(argv[0]);
+    RDATA(argv[0])->dfree = 0; // disown
+    DATA_PTR(argv[0]) = nullptr; // unlink
+    // no need to remove tracking as all Ractor safe events are untracked
+    // queue event
+    wxeh->QueueEvent(wxevt);
+  }
+  else
+  {
+    rb_raise(rb_eRuntimeError, "Event handler already deleted.");
+  }
+
+  return Qnil;
+}
+
+static VALUE wxRuby_EvtHandler_make_shared(VALUE self)
+{
+  void *ptr;
+  wxEvtHandler *wxeh = nullptr;
+  ptr = DATA_PTR(self);
+  wxeh = reinterpret_cast< wxEvtHandler * >(ptr);
+  if (wxeh)
+  {
+    VALUE rb_shared_eh = WxRuby_MakeSharedEvtHandler(wxeh);
+    if (RB_NIL_P(rb_shared_eh))  rb_raise(rb_eRuntimeError, "Unable to create shared event handler");
+    return rb_shared_eh;
+  }
+  else
+  {
+    rb_raise(rb_eRuntimeError, "Object already deleted.");
+    return Qnil;
+  }
+}
+
+static void wx_setup_WxRubySharedEvtHandler(VALUE mWxExt)
+{
+  // mark this extension Ractor safe
+  rb_ext_ractor_safe(true);
+
+  cWxRubySharedEvtHandler = rb_define_class_under(mWxExt, "SharedEvtHandler", rb_cObject);
+  rb_undef_alloc_func(cWxRubySharedEvtHandler);
+  rb_define_method(cWxRubySharedEvtHandler, "clone", VALUEFUNC(WxRubySharedEvtHandler_clone), 0);
+  rb_define_method(cWxRubySharedEvtHandler, "queue_event", VALUEFUNC(WxRubySharedEvtHandler_queue_event), -1);
+
+  VALUE klass = WxRuby_get_EvtHandlerClass();
+  rb_define_method(klass, "make_shared", VALUEFUNC(wxRuby_EvtHandler_make_shared), 0);
+}
+
+#endif