wxruby3 0.9.0.pre.beta.8

data/rakelib/lib/director/printer.rb

@@ -0,0 +1,61 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class Printer < Director
+
+      def setup
+        super
+        spec.items << 'wxPrintout' << 'wxPrintPreview'
+        spec.no_proxy 'wxPrinter', 'wxPrintPreview' # do not see the point in allowing overrides for the standard methods
+        spec.new_object 'wxPrinter::CreateAbortWindow'
+        spec.new_object 'wxPrinter::PrintDialog'
+        # make wxPrinter GC-safe
+        spec.ignore 'wxPrinter::GetPrintDialogData'
+        spec.add_extend_code 'wxPrinter', <<~__HEREDOC
+          wxPrintDialogData* GetPrintDialogData()
+          { return new wxPrintDialogData(self->GetPrintDialogData()); }
+          void SetPrintDialogData(const wxPrintDialogData& pd)
+          { self->GetPrintDialogData() = pd; }
+          __HEREDOC
+        spec.new_object 'wxPrinter::GetPrintDialogData'
+        spec.disown 'wxPrintout *' # Printout-s passed to PrintPreview will be managed by wxWidgets
+        spec.add_header_code <<~__HEREDOC
+          static void GC_mark_wxPrintPreview(void *ptr)
+          {
+            wxPrintPreview* print_preview = (wxPrintPreview*)ptr;
+            wxPrintout* printout = print_preview->GetPrintout();
+            rb_gc_mark( SWIG_RubyInstanceFor(printout) );
+            wxPrintout* printout_for_printing = print_preview->GetPrintoutForPrinting();
+            rb_gc_mark( SWIG_RubyInstanceFor(printout_for_printing) );
+          }
+          __HEREDOC
+        spec.add_swig_code '%markfunc wxPrintPreview "GC_mark_wxPrintPreview";'
+        # for GetCanvas
+        spec.ignore('wxPrintPreview::GetCanvas', ignore_doc: false)
+        spec.extend_interface('wxPrintPreview',
+                              'virtual wxScrolledWindow* GetCanvas() const')
+        # docs only mapping
+        spec.map 'wxPreviewCanvas *' => 'wxScrolledWindow', swig: false do
+          map_out
+        end
+        spec.suppress_warning(473,
+                              'wxPrintPreview::GetCanvas',
+                              'wxPrintPreview::GetFrame',
+                              'wxPrintPreview::GetPrintout',
+                              'wxPrintPreview::GetPrintoutForPrinting')
+        # for various Printout getters
+        spec.add_swig_code '%feature("new", "0") wxPrintout::GetDC;'
+        spec.map_apply 'int * OUTPUT' => 'int *'
+        spec.do_not_generate(:variables, :defines, :enums, :functions) # with PrintAbortDialog
+      end
+    end # class Printer
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/property_grid.rb

@@ -0,0 +1,174 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './window'
+
+module WXRuby3
+
+  class Director
+
+    class PropertyGrid < Window
+
+      include Typemap::PGProperty
+
+      include Typemap::PGCell
+
+      include Typemap::PGPropArg
+
+      def setup
+        super
+        spec.gc_as_window 'wxPropertyGrid'
+        spec.override_inheritance_chain('wxPropertyGrid', %w[wxScrolledControl wxControl wxWindow wxEvtHandler wxObject])
+        spec.add_header_code 'typedef wxScrolled<wxControl> wxScrolledControl;'
+        spec.no_proxy 'wxPropertyGrid::SendAutoScrollEvents',
+                      'wxPropertyGrid::RefreshProperty',
+                      'wxPropertyGrid::GetStatusBar'
+        # not usable in wxRuby
+        spec.ignore 'wxPropertyGrid::SetSortFunction',
+                    'wxPropertyGrid::GetSortFunction'
+        spec.ignore 'wxPropertyGrid::RegisterEditorClass' # defined in pure Ruby
+        spec.disown 'wxPGEditor *editor' # for DoRegisterEditorClass
+        # special doc-only mapping to remove this arg from docs as wxRuby always passes false here
+        spec.map 'bool noDefCheck', swig: false do
+          map_in ignore: true
+        end
+        # replace by custom extension
+        spec.add_header_code <<~__HEREDOC
+          static int wxRuby_PropertyGridSortFunction(wxPropertyGrid* pg, wxPGProperty* pp1, wxPGProperty* pp2)
+          {
+            static WxRuby_ID call_id("call");
+
+            VALUE rb_pg = SWIG_RubyInstanceFor(pg);
+            VALUE rb_pp1 = SWIG_NewPointerObj(SWIG_as_voidptr(pp1), SWIGTYPE_p_wxPGProperty, 0);
+            VALUE rb_pp2 = SWIG_NewPointerObj(SWIG_as_voidptr(pp2), SWIGTYPE_p_wxPGProperty, 0);
+            VALUE rb_sorter = rb_iv_get(rb_pg, "@__sorter");
+            if (NIL_P(rb_sorter))
+            {
+              VALUE msg = rb_inspect(rb_pg);
+              rb_raise(rb_eRuntimeError, "Nil @__sorter for %s",
+                                         StringValuePtr(msg));
+            }
+            return INT2NUM(rb_funcall(rb_sorter, call_id(), 3, rb_pg, rb_pp1, rb_pp2));
+          }
+          __HEREDOC
+        spec.add_extend_code 'wxPropertyGrid', <<~__HEREDOC
+          void SetSorter(VALUE proc)
+          {
+            VALUE rb_self = SWIG_RubyInstanceFor(self);
+            rb_iv_set(rb_self, "@__sorter", proc);
+            self->SetSortFunction(wxRuby_PropertyGridSortFunction);
+          }
+          VALUE GetSorter()
+          {
+            VALUE rb_self = SWIG_RubyInstanceFor(self);
+            return rb_iv_get(rb_self, "@__sorter");
+          }
+          __HEREDOC
+        spec.add_swig_code 'typedef const wxPGPropArgCls& wxPGPropArg;'
+        # mixin PropertyGridInterface
+        spec.include_mixin 'wxPropertyGrid', 'Wx::PG::PropertyGridInterface'
+        # customize mark function
+        spec.add_header_code <<~__HEREDOC
+          static void GC_mark_wxPropertyGrid(void* ptr) 
+          {
+          #ifdef __WXRB_DEBUG__
+            if (wxRuby_TraceLevel()>1)
+              std::wcout << "> GC_mark_wxPropertyGrid : " << ptr << std::endl;
+          #endif
+            if ( GC_IsWindowDeleted(ptr) )
+            {
+              return;
+            }
+            // Do standard marking routines as for all wxWindows
+            GC_mark_wxWindow(ptr);
+            
+            wxPropertyGrid* wx_pg = (wxPropertyGrid*) ptr;
+
+            // mark all properties
+            wxPGVIterator it =
+                wx_pg->GetVIterator(wxPG_ITERATOR_FLAGS_ALL | wxPG_IT_CHILDREN(wxPG_ITERATOR_FLAGS_ALL));
+            // iterate all
+            for ( ; !it.AtEnd(); it.Next() )
+            {
+              wxPGProperty* p = it.GetProperty();
+              VALUE rb_p = SWIG_RubyInstanceFor(p);
+              if (NIL_P(rb_p))
+              {
+                VALUE object = (VALUE) p->GetClientData();
+                if ( object && !NIL_P(object))
+                {
+          #ifdef __WXRB_DEBUG__
+                  if (wxRuby_TraceLevel()>2)
+                    std::wcout << "*** marking property data " << p << ":" << p->GetName() << std::endl;
+          #endif
+                  rb_gc_mark(object);
+                }
+              }
+              else
+              {
+                rb_gc_mark(rb_p);
+              }
+            }
+          }
+          __HEREDOC
+        spec.add_swig_code '%markfunc wxPropertyGrid "GC_mark_wxPropertyGrid";'
+        # missing from XML docs
+        spec.extend_interface 'wxPropertyGrid',
+                              'wxPoint GetGoodEditorDialogPosition(wxPGProperty* p, const wxSize& sz)',
+                              'wxWindow* GetPrimaryEditor() const',
+                              'wxWindow* GetEditorControlSecondary() const',
+                              'wxRect GetPropertyRect(const wxPGProperty* p1, const wxPGProperty* p2) const'
+        # add extension code to retrieve the internal standard editors
+        # can't use the global variables directly to create constants as these will
+        # only be initialized after the app has started so we add a module method
+        # to retrieve the variables and use that to initialize the constants using
+        # delayed init
+        spec.include 'wx/propgrid/advprops.h'
+        spec.add_extend_code 'wxPropertyGrid', <<~__HEREDOC
+          static wxPGEditor* get_standard_editor_class(const wxString& editor_name)
+          {
+            // will trigger registration of all property editors
+            wxPropertyGridInterface::RegisterAdditionalEditors();
+            if (editor_name == wxS("TextCtrl"))
+            {
+              return wxPGEditor_TextCtrl;
+            }
+            if (editor_name == wxS("TextCtrlAndButton"))
+            {
+              return wxPGEditor_TextCtrlAndButton;
+            }
+            if (editor_name == wxS("Choice"))
+            {
+              return wxPGEditor_Choice;
+            }
+            if (editor_name == wxS("ComboBox"))
+            {
+              return wxPGEditor_ComboBox;
+            }
+            if (editor_name == wxS("CheckBox"))
+            {
+              return wxPGEditor_CheckBox;
+            }
+            if (editor_name == wxS("ChoiceAndButton"))
+            {
+              return wxPGEditor_ChoiceAndButton;
+            }
+            if (editor_name == wxS("SpinCtrl"))
+            {
+              return wxPGEditor_SpinCtrl;
+            }
+            if (editor_name == wxS("DatePickerCtrl"))
+            {
+              return wxPGEditor_DatePickerCtrl;
+            }
+            return 0;
+          }
+        __HEREDOC
+      end
+    end # class PropertyGrid
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/property_grid_event.rb

@@ -0,0 +1,23 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './event'
+
+module WXRuby3
+
+  class Director
+
+    include Typemap::PGProperty
+
+    class PropertyGridEvent < Event
+
+      def setup
+        super
+      end
+    end # class PropertyGridEvent
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/property_grid_interface.rb

@@ -0,0 +1,227 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class PropertyGridInterface < Director
+
+      include Typemap::DateTime
+
+      include Typemap::PGProperty
+
+      include Typemap::PGEditor
+
+      include Typemap::PGPropArg
+
+      def setup
+        super
+        spec.gc_as_temporary 'wxPropertyGridInterface' # actually no GC control necessary as this is a mixin only
+        # turn wxPropertyGridInterface into a mixin module
+        spec.make_mixin 'wxPropertyGridInterface'
+        # add typedef to work around flaky define in wxWidgets
+        spec.add_swig_code 'typedef const wxPGPropArgCls& wxPGPropArg;'
+        # for Append, AppendIn, Insert, ReplaceProperty
+        spec.disown 'wxPGProperty *property', 'wxPGProperty *newProperty'
+        spec.ignore 'wxPropertyGridInterface::RemoveProperty' # too problematic bc of GC issues
+        # ignore ALL but the Wx::Variant overload
+        spec.ignore 'wxPropertyGridInterface::SetPropertyValue', ignore_doc: false
+        spec.regard 'wxPropertyGridInterface::SetPropertyValue(wxPGPropArg, wxVariant)'
+        # SWIG chokes on the specified 'defaultCategory' default arg
+        spec.ignore 'wxPropertyGridInterface::SetPropertyValues', ignore_doc: false
+        # so redeclare in way SWIG can process (type map takes care of the defaults; no need for wxVariantList overload)
+        spec.extend_interface 'wxPropertyGridInterface',
+                              'void SetPropertyValues(const wxVariant &list, const wxPGPropArgCls& defaultCategory = 0)'
+        # optionals
+        if Config.instance.features_set?('wxUSE_LONGLONG')
+          spec.set_only_for 'wxLongLong_t',
+                            'wxPropertyGridInterface::GetPropertyValueAsLongLong',
+                            'wxPropertyGridInterface::GetPropertyValueAsULongLong'
+        else
+          spec.ignore 'wxPropertyGridInterface::GetPropertyValueAsLongLong',
+                      'wxPropertyGridInterface::GetPropertyValueAsULongLong'
+        end
+        unless Config.instance.features_set?('wxUSE_DATETIME')
+          spec.ignore 'wxPropertyGridInterface::GetPropertyValueAsDateTime'
+        end
+        unless Config.instance.features_set?('wxUSE_VALIDATORS')
+          spec.ignore 'wxPropertyGridInterface::GetPropertyValidator'
+        end
+        # fix incorrect XML documentation
+        spec.ignore 'wxPropertyGridInterface::SetPropertyImage', ignore_doc: false # ignore non-const BitmapBundle arg decl
+        # and add correct decl
+        spec.extend_interface 'wxPropertyGridInterface', 'void SetPropertyImage(wxPGPropArg id, const wxBitmapBundle &bmp)'
+        # don't expose property grid iterators; add a more Ruby-like extension
+        spec.ignore 'wxPropertyGridInterface::GetIterator', 'wxPropertyGridInterface::GetVIterator'
+        # add basic property enumerator; will wrap this in pure Ruby still for improved argument handling
+        spec.add_extend_code 'wxPropertyGridInterface', <<~__HEREDOC
+          VALUE each_property(int flags, VALUE start, bool reverse)
+          {
+            VALUE rc = Qnil;
+            if (NIL_P(start) && !reverse)
+            {
+              // use faster forward-only iterating over all containers
+              wxPGVIterator prop_it = self->GetVIterator(flags);
+              while (!prop_it.AtEnd())
+              {
+                wxPGProperty* pp = prop_it.GetProperty();
+                VALUE rb_prop = SWIG_NewPointerObj(SWIG_as_voidptr(pp), SWIGTYPE_p_wxPGProperty, 0);
+                rc = rb_yield(rb_prop);
+                prop_it.Next();
+              }
+            }
+            else
+            {
+              wxPropertyGridIterator prop_it;
+              if (NIL_P(start))
+              {
+                prop_it = self->GetIterator(flags, wxBOTTOM); // reverse -> start at end
+              }
+              else if (TYPE(start) == T_DATA)
+              {
+                void* ptr;
+                int res = SWIG_ConvertPtr(start, &ptr,SWIGTYPE_p_wxPGProperty, 0);
+                if (!SWIG_IsOK(res)) 
+                {
+                  VALUE msg = rb_inspect(start);
+                  rb_raise(rb_eArgError, "Expected Integer or PGProperty for 2 but got %s",
+                                         StringValuePtr(msg));
+                }
+                wxPGProperty* pp = static_cast<wxPGProperty*> (ptr);
+                prop_it = self->GetIterator(flags, pp);
+              }
+              else if (TYPE(start) == T_FIXNUM || wxRuby_IsAnEnum(start))
+              {
+                prop_it = self->GetIterator(flags, (int)NUM2INT(start));
+              }
+              else
+              {
+                VALUE msg = rb_inspect(start);
+                rb_raise(rb_eArgError, "Expected Integer or PGProperty for 2 but got %s",
+                                       StringValuePtr(msg));
+              }
+              while (!prop_it.AtEnd())
+              {
+                wxPGProperty* pp = prop_it.GetProperty();
+                VALUE rb_prop = SWIG_NewPointerObj(SWIG_as_voidptr(pp), SWIGTYPE_p_wxPGProperty, 0);
+                rc = rb_yield(rb_prop);
+                reverse ? prop_it.Prev() : prop_it.Next();
+              }
+            }
+            return rc;
+          }
+        __HEREDOC
+        # don't expose wxPGAttributeStorage; add a more Ruby-like extension
+        spec.ignore 'wxPropertyGridInterface::GetPropertyAttributes'
+        spec.add_extend_code 'wxPropertyGridInterface', <<~__HEREDOC
+          VALUE each_property_attribute(const wxPGPropArgCls& proparg)
+          {
+            const wxPGAttributeStorage& att_store = self->GetPropertyAttributes(proparg);
+            wxPGAttributeStorage::const_iterator it = att_store.StartIteration();
+            wxVariant att_var;
+            VALUE rc = Qnil;
+            while (att_store.GetNext(it, att_var))
+            {
+              VALUE rb_att_var = SWIG_NewPointerObj(new wxVariant(att_var), SWIGTYPE_p_wxVariant, SWIG_POINTER_OWN);
+              rc = rb_yield(rb_att_var);
+            }
+            return rc;
+          }
+        __HEREDOC
+        # type mapping for 'wxArrayPGProperty *targetArr' (GetPropertiesWithFlag)
+        spec.map 'wxArrayPGProperty *targetArr' => 'Array<Wx::PG::PGProperty>' do
+          map_in ignore: true, temp: 'wxArrayPGProperty tmp', code: '$1 = &tmp;'
+          map_argout code: <<~__CODE
+            $result = rb_ary_new();
+            for (size_t i = 0; i < $1->GetCount(); i++)
+            {
+              wxPGProperty* pp = $1->Item(i);
+              VALUE rb_pp = SWIG_NewPointerObj(SWIG_as_voidptr(pp), SWIGTYPE_p_wxPGProperty, 0);
+              rb_ary_push($result, rb_pp);
+            }
+            __CODE
+        end
+        # GetState is missing from the XML docs but we want to add a customized version anyway
+        # to be able to return either a PropertyGridPage (for PropertyGridManager) or a PropertyGridPageState
+        # (for PropertyGrid).
+        spec.include 'wx/propgrid/manager.h'
+        spec.add_header_code <<~__CODE
+          extern VALUE mWxPG; // declare external module reference
+
+          static WxRuby_ID pgi_PropertyGridPageState_id("PropertyGridPageState");
+          static WxRuby_ID pgi_PropertyGridPage_id("PropertyGridPage");
+          __CODE
+        spec.add_extend_code 'wxPropertyGridInterface', <<~__HEREDOC
+          VALUE get_state()
+          {
+            // attempt cast
+            wxPropertyGridManager* wx_pgm = dynamic_cast<wxPropertyGridManager*> (self);
+            if (wx_pgm)
+            {
+              return wxRuby_WrapWxObjectInRuby(wx_pgm->GetCurrentPage());
+            }
+            else
+            {
+              wxPropertyGridPageState* wx_pgps = self->GetState();
+              VALUE klass = rb_const_get(mWxPG, pgi_PropertyGridPageState_id());
+              swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(klass); 
+              return SWIG_NewPointerObj(SWIG_as_voidptr(wx_pgps), swig_type, 0);
+            } 
+          }
+          __HEREDOC
+        # In wxRuby PropertyGridPageState is folded into PropertyGridPage so it is not actually
+        # derived from PropertyGridPageState but is one in the sense of Ruby's duck typing so we have
+        # some tinkering to do to make RefreshGrid accept either a PropertyGridPageState (returned from
+        # PropertyGridInterface#GetSate for a PropertyGrid) or a PropertyGridPage (returned either by
+        # PropertyGridInterface#GetState for a PropertyGridManager or any of the PropertyGridManager#GetXXXPage
+        # methods).
+        spec.ignore 'wxPropertyGridInterface::RefreshGrid', ignore_doc: false
+        spec.add_extend_code 'wxPropertyGridInterface', <<~__HEREDOC
+          void RefreshGrid(VALUE rb_state)
+          {
+            wxPropertyGridPageState *state = 0;
+            if (!NIL_P(rb_state))
+            {
+              VALUE klass = rb_const_get(mWxPG, pgi_PropertyGridPageState_id());
+              if (rb_obj_is_kind_of(rb_state, klass))
+              {
+                swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(klass); 
+                int res = SWIG_ConvertPtr(rb_state, SWIG_as_voidptrptr(&state), swig_type, 0);
+                if (!SWIG_IsOK(res)) {
+                  VALUE msg = rb_inspect(rb_state);
+                  rb_raise(rb_eArgError, "Expected PropertyGridPage or PropertyGridPageState for 1 but got %s", 
+                                StringValuePtr(msg));
+                }
+              }
+              else
+              {
+                wxPropertyGridPage *wx_pg = 0;
+                VALUE klass = rb_const_get(mWxPG, pgi_PropertyGridPage_id());
+                swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(klass); 
+                int res = SWIG_ConvertPtr(rb_state, SWIG_as_voidptrptr(&wx_pg), swig_type, 0);
+                if (!SWIG_IsOK(res)) {
+                  VALUE msg = rb_inspect(rb_state);
+                  rb_raise(rb_eArgError, "Expected PropertyGridPage or PropertyGridPageState for 1 but got %s", 
+                                StringValuePtr(msg));
+                }
+                state = wx_pg;
+              }
+            }
+            self->RefreshGrid(state);
+          }
+          __HEREDOC
+        spec.map 'wxPropertyGridPageState *state' => 'Wx::PG::PropertyGridPage,Wx::PG::PropertyGridPageState', swig: false do
+          map_in
+        end
+
+        spec.do_not_generate :variables, :defines, :enums, :functions # with pgproperty
+      end
+    end # class PropertyGridInterface
+
+  end # class Director
+
+
+end # module WXRuby3

data/rakelib/lib/director/property_grid_manager.rb

@@ -0,0 +1,90 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './window'
+
+module WXRuby3
+
+  class Director
+
+    class PropertyGridManager < Window
+
+      include Typemap::PGPropArg
+
+      def setup
+        super
+        spec.override_inheritance_chain('wxPropertyGridManager', %w[wxPanel wxWindow wxEvtHandler wxObject])
+        spec.add_swig_code 'typedef const wxPGPropArgCls& wxPGPropArg;'
+        # mixin PropertyGridInterface
+        spec.include_mixin 'wxPropertyGridManager', 'Wx::PG::PropertyGridInterface'
+        # for AddPage and InsertPage
+        spec.disown 'wxPropertyGridPage *pageObj'
+        spec.suppress_warning(473, 'wxPropertyGridManager::InsertPage')
+        # do not expose iterator class; #each_property provided by PropertyGridInterface mixin
+        spec.ignore 'wxPropertyGridManager::GetVIterator'
+        # customize mark function
+        spec.add_header_code <<~__HEREDOC
+          static void GC_mark_wxPropertyGridManager(void* ptr) 
+          {
+          #ifdef __WXRB_DEBUG__
+            if (wxRuby_TraceLevel()>1)
+              std::wcout << "> GC_mark_wxPropertyGridManager : " << ptr << std::endl;
+          #endif
+            if ( GC_IsWindowDeleted(ptr) )
+            {
+              return;
+            }
+            // Do standard marking routines as for all wxWindows
+            GC_mark_wxWindow(ptr);
+            
+            wxPropertyGridManager* wx_pg = (wxPropertyGridManager*) ptr;
+
+            // mark all properties of all pages
+          #ifdef __WXRB_DEBUG__
+            long l = 0;
+          #endif
+            for (size_t i=0; i < wx_pg->GetPageCount() ;++i)
+            {
+              wxPGVIterator it =
+                  wx_pg->GetPage(i)->GetVIterator(wxPG_ITERATOR_FLAGS_ALL | wxPG_IT_CHILDREN(wxPG_ITERATOR_FLAGS_ALL));
+              // iterate all
+              for ( ; !it.AtEnd(); it.Next() )
+              {
+          #ifdef __WXRB_DEBUG__
+                ++l;
+          #endif
+                wxPGProperty* p = it.GetProperty();
+                VALUE rb_p = SWIG_RubyInstanceFor(p);
+                if (NIL_P(rb_p))
+                {
+                  VALUE object = (VALUE) p->GetClientData();
+                  if ( object && !NIL_P(object))
+                  {
+          #ifdef __WXRB_DEBUG__
+                    if (wxRuby_TraceLevel()>2)
+                      std::wcout << "*** marking property data " << p << ":" << p->GetName() << std::endl;
+          #endif
+                    rb_gc_mark(object);
+                  }
+                }
+                else
+                {
+                  rb_gc_mark(rb_p);
+                }
+              }
+            }
+          #ifdef __WXRB_DEBUG__
+            if (wxRuby_TraceLevel()>1)
+              std::wcout << "*** iterated " << l << " properties" << std::endl;
+          #endif
+          }
+        __HEREDOC
+        spec.add_swig_code '%markfunc wxPropertyGridManager "GC_mark_wxPropertyGridManager";'
+      end
+    end # class PropertyGridManager
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/property_grid_page.rb

@@ -0,0 +1,76 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require_relative './event_handler'
+
+module WXRuby3
+
+  class Director
+
+    class PropertyGridPage < EvtHandler
+
+      include Typemap::PGProperty
+
+      include Typemap::PGPropArg
+
+      def setup
+        super
+        spec.items << 'wxPropertyGridPageState'
+        spec.override_inheritance_chain('wxPropertyGridPage', %w[wxEvtHandler wxObject])
+        # no real use in exposing wxPropertyGridPageState currently
+        spec.fold_bases 'wxPropertyGridPage' => 'wxPropertyGridPageState'
+        # need a custom implementation to handle event handler proc cleanup
+        spec.add_header_code <<~__HEREDOC
+          class WXRubyPropertyGridPage : public wxPropertyGridPage
+          {
+          public:
+            WXRubyPropertyGridPage() : wxPropertyGridPage() {}
+            virtual ~WXRubyPropertyGridPage() 
+            {
+              wxRuby_ReleaseEvtHandlerProcs(this);
+            }               
+          };
+          __HEREDOC
+        spec.use_class_implementation 'wxPropertyGridPage', 'WXRubyPropertyGridPage'
+        spec.ignore 'wxPropertyGridPage::GetStatePtr'
+        if Config.instance.wx_version >= '3.3.0'
+          spec.ignore 'wxPropertyGridPageState::DoSetSplitter'
+        else
+          spec.ignore 'wxPropertyGridPageState::DoSetSplitterPosition'
+        end
+        # mixin PropertyGridInterface
+        spec.include_mixin 'wxPropertyGridPage', 'Wx::PG::PropertyGridInterface'
+        # these are ambiguous bc inherited from both PropertyGridInterface and wxPropertyGridPageState
+        spec.ignore 'wxPropertyGridPageState::GetSelection',
+                    'wxPropertyGridPageState::GetPropertyCategory',
+                    ignore_doc: false
+        # so we create custom extensions to circumvent that
+        spec.add_extend_code 'wxPropertyGridPage', <<~__HEREDOC
+          wxPGProperty* GetSelection () const
+          {
+            return self->wxPropertyGridPageState::GetSelection();
+          }
+
+          wxPropertyCategory* GetPropertyCategory( wxPGPropArg id ) const
+          {
+            return self->wxPropertyGridInterface::GetPropertyCategory(id); 
+          }
+          __HEREDOC
+        spec.add_swig_code 'typedef const wxPGPropArgCls& wxPGPropArg;'
+        # for DoInsert
+        spec.disown 'wxPGProperty *property'
+        # the 'doDelete' argument is troublesome for GC handling in wxRuby so we remove it in the wxRuby interface
+        # and force it to be always 'true' (called with 'false' only from wxPropertyGridInterface::RemoveProperty
+        # which we do not support in wxRuby either)
+        spec.map 'bool doDelete' do
+          map_in ignore: true, code: '$1= true;'
+        end
+        spec.suppress_warning(473, 'wxPropertyGridPage::DoInsert')
+      end
+    end # class PropertyGridPage
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/property_grid_page_state.rb

@@ -0,0 +1,32 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class PropertyGridPageState < Director
+
+      def setup
+        super
+        spec.items << 'wxPropertyGridHitTestResult'
+        spec.gc_never 'wxPropertyGridPageState'
+        spec.gc_as_temporary 'wxPropertyGridHitTestResult'
+        spec.make_abstract 'wxPropertyGridPageState'
+        spec.disable_proxies
+        spec.ignore 'wxPropertyGridPageState::DoDelete',
+                    'wxPropertyGridPageState::DoInsert'
+        if Config.instance.wx_version >= '3.3.0'
+          spec.ignore 'wxPropertyGridPageState::DoSetSplitter'
+        else
+          spec.ignore 'wxPropertyGridPageState::DoSetSplitterPosition'
+        end
+        spec.do_not_generate :variables, :enums, :defines, :functions
+      end
+    end # class PropertyGridPageState
+
+  end # class Director
+
+end # module WXRuby3