wxruby3 0.9.2 → 0.9.4

data/rakelib/lib/director/persistence_manager.rb

@@ -0,0 +1,410 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+module WXRuby3
+
+  class Director
+
+    class PersistenceManager < Director
+
+      include Typemap::ConfigBase
+
+      def setup
+        super
+        spec.gc_as_marked
+        spec.use_class_implementation 'wxPersistenceManager', 'WxRubyPersistenceManager'
+        spec.ignore 'wxPersistenceManager::Register',
+                    'wxPersistenceManager::Find',
+                    'wxPersistenceManager::Unregister',
+                    'wxPersistenceManager::Save',
+                    'wxPersistenceManager::Restore',
+                    'wxPersistenceManager::SaveAndUnregister',
+                    'wxPersistenceManager::RegisterAndRestore',
+                    ignore_doc: false
+        # doc gen only
+        spec.map 'void *obj' => 'Object', swig: false do
+          map_in code: ''
+        end
+        spec.map 'T *obj' => 'Object', swig: false do
+          map_in code: ''
+        end
+        spec.regard 'wxPersistenceManager::wxPersistenceManager',
+                    'wxPersistenceManager::GetConfig',
+                    'wxPersistenceManager::GetKey'
+        spec.suppress_warning 473, 'wxPersistenceManager::GetConfig'
+        spec.ignore %w[wxCreatePersistentObject wxPersistentRegisterAndRestore]
+        spec.add_header_code <<~__HEREDOC
+          #include "wxruby-Persistence.h"
+
+          // default global wxRuby persistence manager
+          static WxRubyPersistenceManager s_wxruby_persistence_manager {};
+
+          static WxRuby_ID to_f_id("to_f");
+          static WxRuby_ID to_i_id("to_i");
+          static WxRuby_ID to_s_id("to_s");
+          static WxRuby_ID save_value_id("save_value");
+          static WxRuby_ID restore_value_id("save_value");
+          static WxRuby_ID create_po_id("create_persistent_object");
+          
+          #ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
+          #define PO_LONG wxLongLong_t
+          #define PO_NUM2LONG(n) NUM2LL(n)
+          #define PO_LONG2NUM(l) LL2NUM(l)
+          #else
+          #define PO_LONG long
+          #define PO_NUM2LONG(n) NUM2LONG(n)
+          #define PO_LONG2NUM(l) LONG2NUM(l)
+          #endif
+
+          bool WxRubyPersistenceManager::SaveRubyValue(const wxPersistentObject& who, const wxString& name, VALUE value)
+          {
+            Swig::Director* dir = dynamic_cast<Swig::Director*> (this);
+            // is this a user defined Ruby persistence manager with overridden #save_value?
+            if (dir && !wxRuby_IsNativeMethod(dir->swig_get_self(), save_value_id())) 
+            {
+              VALUE rb_who = SWIG_NewPointerObj(SWIG_as_voidptr(&who), SWIGTYPE_p_wxPersistentObject,  0 );
+              return wxRuby_Funcall(dir->swig_get_self(), save_value_id(), 3, rb_who, WXSTR_TO_RSTR(name), value);
+            }
+            else
+            {
+              // just call C++ base implementation
+              return DoSaveRubyValue(who, name, value);
+            }
+          }
+
+          VALUE WxRubyPersistenceManager::RestoreRubyValue(const wxPersistentObject& who, const wxString& name)
+          {
+            Swig::Director* dir = dynamic_cast<Swig::Director*> (this);
+            // is this a user defined Ruby persistence manager with overridden #restore_value?
+            if (dir && !wxRuby_IsNativeMethod(dir->swig_get_self(), restore_value_id())) 
+            {
+              VALUE rb_who = SWIG_NewPointerObj(SWIG_as_voidptr(&who), SWIGTYPE_p_wxPersistentObject,  0 );
+              return wxRuby_Funcall(dir->swig_get_self(), restore_value_id(), 3, rb_who, WXSTR_TO_RSTR(name));
+            }
+            else
+            {
+              // just call C++ base implementation
+              return DoRestoreRubyValue(who, name);
+            }
+          }
+
+          bool WxRubyPersistenceManager::DoSaveRubyValue(const wxPersistentObject& who, const wxString& name, VALUE value)
+          {
+            wxConfigBase* cfg = this->GetConfig();
+            if (!cfg)
+              return false;
+            wxString key = this->GetKey(who, name);
+            switch(TYPE(value))
+            {
+              case T_TRUE:
+              case T_FALSE:
+                return cfg->Write(key, value == Qtrue);
+        
+              case T_FIXNUM:
+              case T_BIGNUM:
+                return cfg->Write(key, PO_NUM2LONG(value));
+        
+              case T_FLOAT:
+                return cfg->Write(key, NUM2DBL(value));
+        
+              case T_STRING:
+                return cfg->Write(key, RSTR_TO_WXSTR(value));
+        
+              default:
+                if (rb_respond_to(value, to_i_id()))
+                {
+                  VALUE ival = rb_funcall(value, to_i_id(), 0);
+                  return cfg->Write(key, PO_NUM2LONG(ival));
+                }
+                else if (rb_respond_to(value, to_f_id()))
+                {
+                  VALUE fval = rb_funcall(value, to_f_id(), 0);
+                  return cfg->Write(key, NUM2DBL(fval));
+                }
+                break;
+            }
+            VALUE sval = rb_funcall(value, to_s_id(), 0);
+            return cfg->Write(key, RSTR_TO_WXSTR(sval));
+          }
+
+          VALUE WxRubyPersistenceManager::DoRestoreRubyValue(const wxPersistentObject& who, const wxString& name)
+          {
+            wxConfigBase* cfg = this->GetConfig();
+            if (!cfg)
+              return Qnil;
+            wxString key = this->GetKey(who, name);
+            wxConfigBase::EntryType vtype = cfg->GetEntryType(key);
+            switch(vtype)
+            {
+              case wxConfigBase::Type_Boolean:
+              {
+                bool v;
+                if (cfg->Read(key, &v))
+                {
+                  return v ? Qtrue : Qfalse;
+                }
+                break;
+              }
+              case wxConfigBase::Type_Integer:
+              {
+                PO_LONG v;
+                if (cfg->Read(key, &v))
+                {
+                  return PO_LONG2NUM(v);
+                }
+                break;
+              }
+              case wxConfigBase::Type_Float:
+              {
+                double v;
+                if (cfg->Read(key, &v))
+                {
+                  return DBL2NUM(v);
+                }
+                break;
+              }
+              case wxConfigBase::Type_String:
+              {
+                wxString v;
+                if (cfg->Read(key, &v))
+                {
+                  return WXSTR_TO_RSTR(v);
+                }
+                break;
+              }
+              default:
+                break;
+            }
+            return Qnil;
+          }
+
+          void WxRubyPersistenceManager::UnregisterPersistentObject(VALUE rb_obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = 
+              dynamic_cast<WxRubyPersistenceManager*> (&wxPersistenceManager::Get());
+            if (wxrb_pm) wxrb_pm->UnregisterRbPO(rb_obj);
+          } 
+
+          void WxRubyPersistenceManager::GC_markPO()
+          {
+            rb_object_to_rb_po_map_t::iterator it;
+            for( it = rb_object_po_map_.begin(); it != rb_object_po_map_.end(); ++it )
+            {
+              rb_gc_mark(it->first);
+              rb_gc_mark(it->second);
+            }
+          }
+
+          static void wxRuby_markPersistentObjects()
+          {
+            WxRubyPersistenceManager* wxrb_pm = 
+              dynamic_cast<WxRubyPersistenceManager*> (&wxPersistenceManager::Get());
+            if (wxrb_pm) wxrb_pm->GC_markPO();
+          }
+          __HEREDOC
+        spec.add_extend_code 'wxPersistenceManager', <<~__HEREDOC
+          VALUE Register(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = rb_funcall(obj, create_po_id(), 0);
+            if (!NIL_P(rb_po) && wxrb_pm)
+            {
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, SWIG_POINTER_DISOWN);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Unable to create Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Register(po->GetObject(), po))
+              {
+                wxrb_pm->RegisterRbPO(obj, rb_po);
+                return rb_po;
+              }
+            }
+            return Qnil;
+          }
+
+          VALUE Register(VALUE obj, VALUE rb_po)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            if (!NIL_P(rb_po) && wxrb_pm)
+            {
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, SWIG_POINTER_DISOWN);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Unable to create Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Register(po->GetObject(), po))
+              {
+                wxrb_pm->RegisterRbPO(obj, rb_po);
+                return rb_po;
+              }
+            }
+            return Qnil;
+          }
+
+          VALUE Find(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Find(po->GetObject()))
+                return rb_po;
+            }
+            return Qnil;
+          }
+
+          void Unregister(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              $self->Unregister(po->GetObject());
+            }
+          }
+
+          void Save(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              $self->Save(po->GetObject());
+            }
+          }
+
+          bool Restore(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              return $self->Restore(po->GetObject());
+            }
+            return false;
+          }
+
+          void SaveAndUnregister(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = wxrb_pm ? wxrb_pm->FindRbPO(obj) : Qnil;
+            if (!NIL_P(rb_po) && wxrb_pm)
+            { 
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Invalid Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              $self->Save(po->GetObject());
+              $self->Unregister(po->GetObject());
+            }
+          }
+
+          bool RegisterAndRestore(VALUE obj)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            VALUE rb_po = rb_funcall(obj, create_po_id(), 0);
+            if (!NIL_P(rb_po) && wxrb_pm)
+            {
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, SWIG_POINTER_DISOWN);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Unable to create Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Register(po->GetObject(), po))
+              {
+                wxrb_pm->RegisterRbPO(obj, rb_po);
+                return $self->Restore(po->GetObject());
+              }
+            }
+            return false;
+          }
+
+          bool RegisterAndRestore(VALUE obj, VALUE rb_po)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            if (!NIL_P(rb_po) && wxrb_pm)
+            {
+              void* ptr;
+              int res = SWIG_ConvertPtr(rb_po, &ptr, SWIGTYPE_p_wxPersistentObject, SWIG_POINTER_DISOWN);
+              if (!SWIG_IsOK(res)) 
+              {
+                rb_raise(rb_eRuntimeError, "Unable to create Wx::PersistentObject for object"); 
+              }
+              wxPersistentObject* po = reinterpret_cast< wxPersistentObject * >(ptr);
+              if ($self->Register(po->GetObject(), po))
+              {
+                wxrb_pm->RegisterRbPO(obj, rb_po);
+                return $self->Restore(po->GetObject());
+              }
+            }
+            return false;
+          }
+          
+          bool SaveValue(const wxPersistentObject& who, const wxString& name, VALUE value)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            return wxrb_pm ? wxrb_pm->DoSaveRubyValue(who, name, value) : false;
+          } 
+
+          VALUE RestoreValue(const wxPersistentObject& who, const wxString& name)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> ($self);
+            return wxrb_pm ? wxrb_pm->DoRestoreRubyValue(who, name) : Qnil;
+          }
+          __HEREDOC
+        spec.add_init_code <<~__HEREDOC
+          // install the default global wxRuby persistence manager
+          wxPersistenceManager::Set(s_wxruby_persistence_manager);
+          // and the persistent object marker
+          wxRuby_AppendMarker(wxRuby_markPersistentObjects);
+          __HEREDOC
+      end
+
+    end # class PersistenceManager
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/persistent_object.rb

@@ -0,0 +1,70 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+module WXRuby3
+
+  class Director
+
+    class PersistentObject < Director
+
+      def setup
+        super
+        spec.gc_as_marked
+        spec.add_header_code <<~__HEREDOC
+          #include "wxruby-Persistence.h"
+
+          WxRubyPersistentObject::WxRubyPersistentObject(VALUE rb_obj)
+            : wxPersistentObject((void*)rb_obj)
+          {}
+
+          WxRubyPersistentObject::~WxRubyPersistentObject()
+          {
+            if (this->GetObject())
+              WxRubyPersistenceManager::UnregisterPersistentObject(
+                reinterpret_cast<VALUE> (this->GetObject()));
+          } 
+          __HEREDOC
+        spec.use_class_implementation 'wxPersistentObject', 'WxRubyPersistentObject'
+        spec.ignore %w[wxPersistentObject::GetObject wxPersistentObject::wxPersistentObject]
+        spec.ignore %w[wxCreatePersistentObject wxPersistentRegisterAndRestore]
+        spec.extend_interface 'wxPersistentObject',
+                              'wxPersistentObject(VALUE rb_obj)',
+                              visibility: 'protected'
+        spec.add_extend_code 'wxPersistentObject', <<~__HEREDOC
+          bool SaveValue(const wxString& name, VALUE value)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> (&wxPersistenceManager::Get());
+            return wxrb_pm ? wxrb_pm->SaveRubyValue(*$self, name, value) : false;
+          }
+          VALUE RestoreValue(const wxString& name)
+          {
+            WxRubyPersistenceManager* wxrb_pm = dynamic_cast<WxRubyPersistenceManager*> (&wxPersistenceManager::Get());
+            return wxrb_pm ? wxrb_pm->RestoreRubyValue(*$self, name) : Qnil;
+          } 
+          __HEREDOC
+        spec.add_extend_code 'wxPersistentObject', <<~__HEREDOC
+          VALUE GetObject()
+          {
+            WxRubyPersistentObject* rpo = dynamic_cast<WxRubyPersistentObject*> ($self);
+            if (rpo)
+            {
+              return reinterpret_cast<VALUE> (rpo->GetObject());
+            } 
+            else
+            {
+              return Qnil;
+            }
+          }
+          __HEREDOC
+        super
+      end
+    end # class PersistentObject
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/persistent_window.rb

@@ -0,0 +1,73 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+module WXRuby3
+
+  class Director
+
+    class PersistentWindow < Director
+
+      def setup
+        spec.items << 'wxPersistentTLW' << 'wxPersistentBookCtrl' << 'wxPersistentTreeBookCtrl'
+        if Config.instance.wx_version >= '3.3.0'
+          # before 3.3.0 this was not properly available
+          spec.items << 'wxPersistentComboBox'
+        end
+        super
+        spec.gc_as_marked
+        spec.use_template_as_class('wxPersistentWindow', 'wxPersistentWindowBase')
+        spec.override_inheritance_chain('wxPersistentWindow', %w[wxPersistentObject])
+        spec.ignore 'wxPersistentWindow::wxPersistentWindow',
+                    'wxPersistentWindow::Get',
+                    ignore_doc: false
+        # make ctor protected because of pure virt methods
+        spec.extend_interface 'wxPersistentWindow',
+                              'wxPersistentWindowBase(wxWindow *win)',
+                              visibility: 'protected'
+        spec.add_header_code 'typedef wxWindow WindowType;'
+        spec.add_swig_code 'typedef wxWindow WindowType;'
+        spec.map 'WindowType *' => 'Wx::Window', swig: false do
+          map_in code: ''
+          map_out code: ''
+        end
+        spec.add_extend_code 'wxPersistentWindowBase', <<~__HEREDOC
+          wxWindow * GetObject()
+          {
+            return reinterpret_cast<wxWindow*> ($self->GetObject());
+          }
+        __HEREDOC
+        # wxPersistentTLW
+        spec.override_inheritance_chain('wxPersistentTLW', [{ 'wxPersistentWindowBase' => 'wxPersistentWindow' }, 'wxPersistentObject'])
+        # add method override missing from docs
+        spec.extend_interface 'wxPersistentTLW',
+                              'virtual wxString GetKind() const override'
+        # wxPersistentBookCtrl
+        spec.override_inheritance_chain('wxPersistentBookCtrl', [{ 'wxPersistentWindowBase' => 'wxPersistentWindow' }, 'wxPersistentObject'])
+        # add method override missing from docs
+        spec.extend_interface 'wxPersistentBookCtrl',
+                              'virtual wxString GetKind() const override'
+        # wxPersistentTreeBookCtrl
+        spec.override_inheritance_chain('wxPersistentTreeBookCtrl', ['wxPersistentBookCtrl', { 'wxPersistentWindowBase' => 'wxPersistentWindow' }, 'wxPersistentObject'])
+        # add method override missing from docs
+        spec.extend_interface 'wxPersistentTreeBookCtrl',
+                              'virtual wxString GetKind() const override'
+        spec.do_not_generate :functions, :defines, :typedefs, :variables, :enums
+        if Config.instance.wx_version >= '3.0.0'
+          # wxPersistentComboBox
+          spec.override_inheritance_chain('wxPersistentComboBox', [{ 'wxPersistentWindowBase' => 'wxPersistentWindow' }, 'wxPersistentObject'])
+          # add method override missing from docs
+          spec.extend_interface 'wxPersistentComboBox',
+                                'virtual wxString GetKind() const override'
+        end
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/director/pgproperty.rb

@@ -18,6 +18,8 @@ module WXRuby3
 
       include Typemap::PGCell
 
+      include Typemap::ClientData
+
       def setup
         super
         if spec.module_name == 'wxPGProperty'
@@ -113,7 +115,7 @@ module WXRuby3
           # obsolete
           spec.ignore %w[wxPGProperty::AddChild wxPGProperty::GetValueString]
           # not of use in Ruby
-          spec.ignore(%w[wxPGProperty::GetClientObject wxPGProperty::SetClientObject])
+          spec.ignore(%w[wxPGProperty::GetClientData wxPGProperty::SetClientData])
           # only keep the const version
           spec.ignore 'wxPGProperty::GetCell'
           spec.regard 'wxPGProperty::GetCell(unsigned int) const'
@@ -146,32 +148,6 @@ module WXRuby3
           spec.suppress_warning(473,
                                 'wxPGProperty::DoGetEditorClass',
                                 'wxPGProperty::DoGetValidator')
-          spec.add_header_code <<~__HEREDOC
-            extern void GC_mark_wxPGProperty(void* ptr)
-            {
-            #ifdef __WXRB_DEBUG__
-              if (wxRuby_TraceLevel()>1)
-              {
-                std::wcout << "> GC_mark_wxPGProperty : " << ptr;
-                if (ptr) std::wcout << " (" << ((wxPGProperty*)ptr)->GetName() << ')';
-                std::wcout << std::endl;
-              }
-            #endif
-              if (ptr)
-              {
-                VALUE object = (VALUE)((wxPGProperty*)ptr)->GetClientData();
-                if (object && !NIL_P(object))
-                {
-            #ifdef __WXRB_DEBUG__
-                  if (wxRuby_TraceLevel()>2)
-                    std::wcout << "*** marking property data " << ptr << std::endl;
-            #endif
-                  rb_gc_mark(object);
-                }
-              }
-            }
-            __HEREDOC
-          spec.add_swig_code '%markfunc wxPGProperty "GC_mark_wxPGProperty";'
           spec.ignore 'wxPGProperty::m_clientData' # not wanted for wxRuby
           # take protected members into account
           spec.regard 'wxPGProperty::wxPGProperty',
@@ -237,7 +213,6 @@ module WXRuby3
             }
             __CODE
         else
-          spec.add_header_code 'extern void GC_mark_wxPGProperty(void* ptr);'
           spec.items.each do |itm|
             unless itm == 'wxColourPropertyValue'
               # add protected member methods and var to complement base class
@@ -250,7 +225,6 @@ module WXRuby3
                                     'wxVariant m_value',
                                     visibility: 'protected'
               spec.rename_for_ruby 'value_' => "#{itm}::m_value"
-              spec.add_swig_code %Q{%markfunc #{itm} "GC_mark_wxPGProperty";}
               spec.new_object %Q{#{itm}::GetEditorDialog}
               spec.suppress_warning(473, "#{itm}::GetEditorDialog")
             end

data/rakelib/lib/director/ribbon_button_bar.rb

@@ -14,13 +14,13 @@ module WXRuby3
 
     class RibbonButtonBar < Window
 
+      include Typemap::ClientData
+
       def setup
         super
         # exclude these; far better done in pure Ruby
         spec.ignore 'wxRibbonButtonBar::SetItemClientData',
-                    'wxRibbonButtonBar::GetItemClientData', ignore_doc: false
-        spec.ignore 'wxRibbonButtonBar::SetItemClientObject',
-                    'wxRibbonButtonBar::GetItemClientObject'
+                    'wxRibbonButtonBar::GetItemClientData'
         # not needed because of type mapping
         spec.ignore 'wxRibbonButtonBar::GetItemId',
                     'wxRibbonButtonBar::GetItemById'

data/rakelib/lib/director/ribbon_gallery.rb

@@ -14,15 +14,13 @@ module WXRuby3
 
     class RibbonGallery < Window
 
+      include Typemap::ClientData
+
       def setup
         super
-        # exclude these; far better done in pure Ruby
-        spec.ignore 'wxRibbonGallery::SetItemClientObject',
-                    'wxRibbonGallery::GetItemClientObject',
-                    'wxRibbonGallery::Append(const wxBitmap &, int, wxClientData *)'
         spec.ignore 'wxRibbonGallery::SetItemClientData',
                     'wxRibbonGallery::GetItemClientData',
-                    'wxRibbonGallery::Append(const wxBitmap &, int, void *)', ignore_doc: false
+                    'wxRibbonGallery::Append(const wxBitmap &, int, void *)'
         spec.map 'wxRibbonGalleryItem*' => 'Integer' do
           map_out code: '$result = ULL2NUM(reinterpret_cast<uintptr_t> ($1));'
           map_directorout code: '$result = reinterpret_cast<wxRibbonGalleryItem*> ((uintptr_t)NUM2ULL($1));'