wxruby3 1.6.1 → 1.8.0

data/rakelib/lib/director/grid_ctrl.rb

@@ -44,6 +44,12 @@ module WXRuby3
         spec.ignore 'wxGrid::SetCellValue(const wxString &,int,int)'
         spec.ignore 'wxGrid::SetTable' # there is wxGrid::AssignTable now that always takes ownership
 
+        spec.regard 'wxGrid::CanHaveAttributes',
+                    'wxGrid::GetColMinimalWidth',
+                    'wxGrid::GetColRight',
+                    'wxGrid::GetColLeft',
+                    'wxGrid::GetRowMinimalHeight'
+
         spec.regard 'wxGridSizesInfo::m_sizeDefault',
                     'wxGridSizesInfo::m_customSizes'
         spec.rename_for_ruby 'size_default' => 'wxGridSizesInfo::m_sizeDefault',
@@ -175,12 +181,14 @@ module WXRuby3
         spec.disown('wxGridTableBase* table')
         # customize mark function to handle safeguarding any customized Grid tables installed
         spec.add_header_code <<~__HEREDOC
+          WXRUBY_TRACE_GUARD(WxRubyTraceGCMarkGrid, "GC_MARK_GRID")
+
           static void GC_mark_wxGridCtrl(void* ptr) 
           {
-          #ifdef __WXRB_DEBUG__
-            if (wxRuby_TraceLevel()>1)
-              std::wcout << "> GC_mark_wxGridCtrl : " << ptr << std::endl;
-          #endif
+            WXRUBY_TRACE_IF(WxRubyTraceGCMarkGrid, 2)
+              WXRUBY_TRACE("> GC_mark_wxGridCtrl : " << ptr)
+            WXRUBY_TRACE_END
+
             if ( GC_IsWindowDeleted(ptr) )
             {
               return;
@@ -194,8 +202,16 @@ module WXRuby3
             VALUE rb_gtbl = SWIG_RubyInstanceFor(wx_gtbl);
             if (!NIL_P(rb_gtbl))
             {
+              WXRUBY_TRACE_IF(WxRubyTraceGCMarkGrid, 3)
+                WXRUBY_TRACE("| GC_mark_wxGridCtrl : marking gridtable " << wx_gtbl << " -> " << rb_gtbl);
+              WXRUBY_TRACE_END
+
               rb_gc_mark(rb_gtbl);
             }
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCMarkGrid, 2)
+              WXRUBY_TRACE("< GC_mark_wxGridCtrl : " << ptr)
+            WXRUBY_TRACE_END
           }
         __HEREDOC
         spec.add_swig_code '%markfunc wxGrid "GC_mark_wxGridCtrl";'
@@ -293,34 +309,56 @@ module WXRuby3
         spec.add_header_code <<~__HEREDOC
           #include <wx/clntdata.h>
 
-          // declare the global table for grid cell attributes
-          WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
-                                      WXRBGridCellAttrValueHash);
-          static WXRBGridCellAttrValueHash Grid_Cell_Attr_Value_Map;
+          WXRUBY_TRACE_GUARD(WxRubyTraceGCMarkGridCellAttr, "GC_MARK_GRID_CELL_ATTR")
+          WXRUBY_TRACE_GUARD(WxRubyTraceGCTrackGridCellAttr, "GC_TRACK_GRID_CELL_ATTR")
+          WXRUBY_TRACE_GUARD(WxRubyTraceGCMarkGridCellEditor, "GC_MARK_GRID_CELL_EDITOR")
+          WXRUBY_TRACE_GUARD(WxRubyTraceGCTrackGridCellEditor, "GC_TRACK_GRID_CELL_EDITOR")
+          WXRUBY_TRACE_GUARD(WxRubyTraceGCMarkGridCellRenderer, "GC_MARK_GRID_CELL_RENDERER")
+          WXRUBY_TRACE_GUARD(WxRubyTraceGCTrackGridCellRenderer, "GC_TRACK_GRID_CELL_RENDERER")
 
-          static void wxRuby_UnregisterGridCellAttr(wxGridCellAttr* wx_attr)
+          static const std::string WXRUBY_GRID_CELL_ATTR = { "WXRUBY_GRID_CELL_ATTR" };
+
+          // define the grid cell attribute marker
+          static void wxRuby_markGridCellAttr(const TGCTrackingValueMap& values)
           {
-          #ifdef __WXRB_DEBUG__
-            if (wxRuby_TraceLevel()>1)
-              std::wcout << "** wxRuby_UnregisterGridCellAttr : " << wx_attr << ":" << (void*)Grid_Cell_Attr_Value_Map[wx_attr] << std::endl;
-          #endif
-            if (Grid_Cell_Attr_Value_Map.count(wx_attr) != 0)
+            WXRUBY_TRACE_IF(WxRubyTraceGCMarkGridCellAttr, 2)
+              WXRUBY_TRACE("> wxRuby_markGridCellAttr")
+            WXRUBY_TRACE_END
+
+            for(const auto& ti : values)
             {
-              VALUE object = Grid_Cell_Attr_Value_Map[wx_attr];  
-              if (object && !NIL_P(object)) 
-              {
-                DATA_PTR(object) = 0; // unlink
-              }
-              Grid_Cell_Attr_Value_Map.erase(wx_attr);
+              VALUE obj = ti.second;
+
+              WXRUBY_TRACE_IF(WxRubyTraceGCMarkGridCellAttr, 2)
+                WXRUBY_TRACE_WITH(void *c_ptr = (TYPE(obj) == T_DATA ? DATA_PTR(obj) : 0))
+                WXRUBY_TRACE("| wxRuby_markGridCellAttr : " << ti.first << "|" << (void*)c_ptr)
+              WXRUBY_TRACE_END
+
+              rb_gc_mark(obj);
             }
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCMarkGridCellAttr, 2)
+              WXRUBY_TRACE("< wxRuby_markGridCellAttr")
+            WXRUBY_TRACE_END
+          }
+
+          static void wxRuby_UnregisterGridCellAttr(wxGridCellAttr* wx_attr)
+          {
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellAttr, 2)
+              WXRUBY_TRACE("> wxRuby_UnregisterGridCellAttr : " << wx_attr << " -> " << wxRuby_FindCategoryValue(WXRUBY_GRID_CELL_ATTR, wx_attr))
+            WXRUBY_TRACE_END
+
+            wxRuby_UnlinkCategoryValue(WXRUBY_GRID_CELL_ATTR, wx_attr);
+            wxRuby_UnregisterCategoryValue(WXRUBY_GRID_CELL_ATTR, wx_attr);
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellAttr, 2)
+              WXRUBY_TRACE("< wxRuby_UnregisterGridCellAttr : " << wx_attr)
+            WXRUBY_TRACE_END
           }
 
           extern VALUE wxRuby_GridCellAttrInstance(wxGridCellAttr* wx_attr)
           {
-            if (Grid_Cell_Attr_Value_Map.count(wx_attr) == 0)
-              return Qnil;
-            else
-              return Grid_Cell_Attr_Value_Map[wx_attr];
+            return wxRuby_FindCategoryValue(WXRUBY_GRID_CELL_ATTR, wx_attr);
           }
 
           // specialized client data class
@@ -329,7 +367,7 @@ module WXRuby3
           public:
             WXRBGridCellAttrMonitor() : wx_attr(0), rb_attr(Qnil) {}
             WXRBGridCellAttrMonitor(wxGridCellAttr* a, VALUE v) : wx_attr(a), rb_attr(v) 
-            { Grid_Cell_Attr_Value_Map[wx_attr] = rb_attr; }
+            { wxRuby_RegisterCategoryValue(WXRUBY_GRID_CELL_ATTR, wx_attr, rb_attr); }
             virtual ~WXRBGridCellAttrMonitor()
             { wxRuby_UnregisterGridCellAttr(wx_attr); }
           private:
@@ -340,60 +378,88 @@ module WXRuby3
           // and it's associated registration/de-registration functions
           extern void wxRuby_RegisterGridCellAttr(wxGridCellAttr* wx_attr, VALUE rb_attr)
           {
+            static bool is_marker_registered = false;
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellAttr, 2)
+              WXRUBY_TRACE("> wxRuby_RegisterGridCellAttr : " << wx_attr << " -> " << rb_attr)
+            WXRUBY_TRACE_END
+
             if (wx_attr && !NIL_P(rb_attr))
             {
-              // always (keep) disown(ed); wxWidgets takes over ownership
-              RDATA(rb_attr)->dfree = 0;
-              if (Grid_Cell_Attr_Value_Map.count(wx_attr) == 0)
+              if (!is_marker_registered)
+              {
+                wxRuby_RegisterTrackingCategory(WXRUBY_GRID_CELL_ATTR, wxRuby_markGridCellAttr, true);
+                is_marker_registered = true;
+              }
+ 
+              // see if this attr is already tracked 
+              if (wxRuby_FindCategoryValue(WXRUBY_GRID_CELL_ATTR, wx_attr) == Qnil)
               {
-          #ifdef __WXRB_DEBUG__
-                if (wxRuby_TraceLevel()>1)
-                  std::wcout << "** wxRuby_RegisterGridCellAttr : " << wx_attr << ":" << (void*)rb_attr << std::endl;
-          #endif
+                WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellAttr, 2)
+                  WXRUBY_TRACE("| wxRuby_RegisterGridCellAttr : installing monitor")
+                WXRUBY_TRACE_END
+
+                // either a new Ruby created instance or an unwrapped C++ created instance 
+                // always disown; wxWidgets takes over or keeps ownership of reference count
+                RDATA(rb_attr)->dfree = 0;
+
                 wx_attr->SetClientObject(new WXRBGridCellAttrMonitor(wx_attr, rb_attr));
               }
+              else  // already registered; will be disowned already
+              {
+                // increase the reference count for C++ to take over
+                wx_attr->IncRef();
+              }
             }
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellAttr, 2)
+              WXRUBY_TRACE("< wxRuby_RegisterGridCellAttr : " << wx_attr)
+            WXRUBY_TRACE_END
           }
 
-          // define the grid cell attribute marker
-          static void wxRuby_markGridCellAttr()
+          static const std::string WXRUBY_GRID_CELL_EDITOR = { "WXRUBY_GRID_CELL_EDITOR" };
+
+          // define the grid cell editor marker
+          static void wxRuby_markGridCellEditor(const TGCTrackingValueMap& values)
           {
-            WXRBGridCellAttrValueHash::iterator it;
-            for( it = Grid_Cell_Attr_Value_Map.begin(); it != Grid_Cell_Attr_Value_Map.end(); ++it )
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellEditor, 2)
+              WXRUBY_TRACE("> wxRuby_markGridCellEditor")
+            WXRUBY_TRACE_END
+
+            for(const auto& ti : values)
             {
-              VALUE obj = it->second;
+              VALUE obj = ti.second;
+
+              WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellEditor, 2)
+                WXRUBY_TRACE_WITH(void *c_ptr = (TYPE(obj) == T_DATA ? DATA_PTR(obj) : 0))
+                WXRUBY_TRACE("| wxRuby_markGridCellEditor : " << ti.first << "|" << (void*)c_ptr)
+              WXRUBY_TRACE_END
+
               rb_gc_mark(obj);
             }
-          }
 
-          // declare the global table for grid cell editors
-          WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
-                                      WXRBGridCellEditorValueHash);
-          static WXRBGridCellEditorValueHash Grid_Cell_Editor_Value_Map;
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellEditor, 2)
+              WXRUBY_TRACE("< wxRuby_markGridCellEditor")
+            WXRUBY_TRACE_END
+          }
 
           static void wxRuby_UnregisterGridCellEditor(wxGridCellEditor* wx_edt)
           {
-          #ifdef __WXRB_DEBUG__
-            if (wxRuby_TraceLevel()>1)
-              std::wcout << "** wxRuby_UnregisterGridCellEditor : " << wx_edt << ":" << (void*)Grid_Cell_Editor_Value_Map[wx_edt] << std::endl;
-          #endif
-            if (Grid_Cell_Editor_Value_Map.count(wx_edt) != 0)
-            {
-              VALUE object = Grid_Cell_Editor_Value_Map[wx_edt];  
-              if (object && !NIL_P(object)) 
-              {
-                DATA_PTR(object) = 0; // unlink
-              }
-              Grid_Cell_Editor_Value_Map.erase(wx_edt);
-            }
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellEditor, 2)
+              WXRUBY_TRACE("> wxRuby_UnregisterGridCellEditor : " << wx_edt << " -> " << wxRuby_FindCategoryValue(WXRUBY_GRID_CELL_EDITOR, wx_edt))
+            WXRUBY_TRACE_END
+
+            wxRuby_UnlinkCategoryValue(WXRUBY_GRID_CELL_EDITOR, wx_edt);
+            wxRuby_UnregisterCategoryValue(WXRUBY_GRID_CELL_EDITOR, wx_edt);
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellEditor, 2)
+              WXRUBY_TRACE("< wxRuby_UnregisterGridCellEditor : " << wx_edt)
+            WXRUBY_TRACE_END
           }
 
           extern VALUE wxRuby_GridCellEditorInstance(wxGridCellEditor* wx_edt)
           {
-            if (Grid_Cell_Editor_Value_Map.count(wx_edt) == 0)
-              return Qnil;
-            else
-              return Grid_Cell_Editor_Value_Map[wx_edt];
+            return wxRuby_FindCategoryValue(WXRUBY_GRID_CELL_EDITOR, wx_edt);
           }
 
           // specialized client data class
@@ -402,7 +468,7 @@ module WXRuby3
           public:
             WXRBGridCellEditorMonitor() : wx_edt(0), rb_edt(Qnil) {}
             WXRBGridCellEditorMonitor(wxGridCellEditor* a, VALUE v) : wx_edt(a), rb_edt(v) 
-            { Grid_Cell_Editor_Value_Map[wx_edt] = rb_edt; }
+            { wxRuby_RegisterCategoryValue(WXRUBY_GRID_CELL_EDITOR, wx_edt, rb_edt); }
             virtual ~WXRBGridCellEditorMonitor()
             { wxRuby_UnregisterGridCellEditor(wx_edt); }
           private:
@@ -413,59 +479,88 @@ module WXRuby3
           // and it's associated registration function
           extern void wxRuby_RegisterGridCellEditor(wxGridCellEditor* wx_edt, VALUE rb_edt)
           {
+            static bool is_marker_registered = false;
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellEditor, 2)
+              WXRUBY_TRACE("> wxRuby_RegisterGridCellEditor : " << wx_edt << " -> " << rb_edt)
+            WXRUBY_TRACE_END
+
             if (wx_edt && !NIL_P(rb_edt))
             {
-              // always (keep) disown(ed); wxWidgets takes over ownership
-              RDATA(rb_edt)->dfree = 0;
-              if (Grid_Cell_Editor_Value_Map.count(wx_edt) == 0)
+              if (!is_marker_registered)
               {
-          #ifdef __WXRB_DEBUG__
-                if (wxRuby_TraceLevel()>1)
-                  std::wcout << "** wxRuby_RegisterGridCellEditor : " << wx_edt << ":" << (void*)rb_edt << std::endl;
-          #endif
+                wxRuby_RegisterTrackingCategory(WXRUBY_GRID_CELL_EDITOR, wxRuby_markGridCellEditor, true);
+                is_marker_registered = true;
+              }
+ 
+              // see if this renderer is already tracked 
+              if (wxRuby_FindCategoryValue(WXRUBY_GRID_CELL_EDITOR, wx_edt) == Qnil)
+              {
+                WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellEditor, 2)
+                  WXRUBY_TRACE("| wxRuby_RegisterGridCellEditor : installing monitor")
+                WXRUBY_TRACE_END
+
+                // either a new Ruby created instance or an unwrapped C++ created instance 
+                // always disown; wxWidgets takes over or keeps ownership of reference count
+                RDATA(rb_edt)->dfree = 0;
+
                 wx_edt->SetClientObject(new WXRBGridCellEditorMonitor(wx_edt, rb_edt));
               }
+              else  // already registered; will be disowned already
+              {
+                // increase the reference count for C++ to take over
+                wx_edt->IncRef();
+              }
             }
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellEditor, 2)
+              WXRUBY_TRACE("< wxRuby_RegisterGridCellEditor : " << wx_edt)
+            WXRUBY_TRACE_END
           }
 
-          // define the grid cell editor marker
-          static void wxRuby_markGridCellEditor()
+          static const std::string WXRUBY_GRID_CELL_RENDERER = { "WXRUBY_GRID_CELL_RENDERER" };
+
+          // define the grid cell renderer marker
+          static void wxRuby_markGridCellRenderer(const TGCTrackingValueMap& values)
           {
-            WXRBGridCellEditorValueHash::iterator it;
-            for( it = Grid_Cell_Editor_Value_Map.begin(); it != Grid_Cell_Editor_Value_Map.end(); ++it )
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellRenderer, 2)
+              WXRUBY_TRACE("> wxRuby_markGridCellRenderer")
+            WXRUBY_TRACE_END
+
+            for(const auto& ti : values)
             {
-              VALUE obj = it->second;
+              VALUE obj = ti.second;
+
+              WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellRenderer, 2)
+                WXRUBY_TRACE_WITH(void *c_ptr = (TYPE(obj) == T_DATA ? DATA_PTR(obj) : 0))
+                WXRUBY_TRACE("| wxRuby_markGridCellRenderer : " << ti.first << "|" << (void*)c_ptr)
+              WXRUBY_TRACE_END
+
               rb_gc_mark(obj);
             }
-          }
 
-          // declare the global table for grid cell renderer
-          WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
-                                      WXRBGridCellRendererValueHash);
-          static WXRBGridCellRendererValueHash Grid_Cell_Renderer_Value_Map;
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellRenderer, 2)
+              WXRUBY_TRACE("< wxRuby_markGridCellRenderer")
+            WXRUBY_TRACE_END
+          }
 
           static void wxRuby_UnregisterGridCellRenderer(wxGridCellRenderer* wx_rnd)
           {
-          #ifdef __WXRB_DEBUG__
-            if (wxRuby_TraceLevel()>1)
-              std::wcout << "** wxRuby_UnregisterGridCellRenderer : " << wx_rnd << ":" << (void*)Grid_Cell_Renderer_Value_Map[wx_rnd] << std::endl;
-          #endif
-            if (Grid_Cell_Renderer_Value_Map.count(wx_rnd) != 0)
-            {
-              VALUE object = Grid_Cell_Renderer_Value_Map[wx_rnd];  
-              if (object && !NIL_P(object)) 
-              {
-                DATA_PTR(object) = 0; // unlink
-              }
-              Grid_Cell_Renderer_Value_Map.erase(wx_rnd);
-            }
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellRenderer, 2)
+              WXRUBY_TRACE("> wxRuby_UnregisterGridCellRenderer : " << wx_rnd << " -> " << wxRuby_FindCategoryValue(WXRUBY_GRID_CELL_RENDERER, wx_rnd))
+            WXRUBY_TRACE_END
+
+            wxRuby_UnlinkCategoryValue(WXRUBY_GRID_CELL_RENDERER, wx_rnd);
+            wxRuby_UnregisterCategoryValue(WXRUBY_GRID_CELL_RENDERER, wx_rnd);
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellRenderer, 2)
+              WXRUBY_TRACE("< wxRuby_UnregisterGridCellRenderer : " << wx_rnd)
+            WXRUBY_TRACE_END
           }
 
           extern VALUE wxRuby_GridCellRendererInstance(wxGridCellRenderer* wx_rnd)
           {
-            if (Grid_Cell_Renderer_Value_Map.count(wx_rnd) == 0)
-              return Qnil;
-            return Grid_Cell_Renderer_Value_Map[wx_rnd];
+            return wxRuby_FindCategoryValue(WXRUBY_GRID_CELL_RENDERER, wx_rnd);
           }
 
           // specialized client data class
@@ -474,7 +569,7 @@ module WXRuby3
           public:
             WXRBGridCellRendererMonitor() : wx_rnd(0), rb_rnd(Qnil) {}
             WXRBGridCellRendererMonitor(wxGridCellRenderer* a, VALUE v) : wx_rnd(a), rb_rnd(v) 
-            { Grid_Cell_Renderer_Value_Map[wx_rnd] = rb_rnd; }
+            { wxRuby_RegisterCategoryValue(WXRUBY_GRID_CELL_RENDERER, wx_rnd, rb_rnd); }
             virtual ~WXRBGridCellRendererMonitor()
             { wxRuby_UnregisterGridCellRenderer(wx_rnd); }
           private:
@@ -485,37 +580,46 @@ module WXRuby3
           // and it's associated registration/de-registration functions
           extern void wxRuby_RegisterGridCellRenderer(wxGridCellRenderer* wx_rnd, VALUE rb_rnd)
           {
+            static bool is_marker_registered = false;
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellRenderer, 2)
+              WXRUBY_TRACE("> wxRuby_RegisterGridCellRenderer : " << wx_rnd << " -> " << rb_rnd)
+            WXRUBY_TRACE_END
+
             if (wx_rnd && !NIL_P(rb_rnd))
             {
-              // always (keep) disowned(ed); wxWidgets takes over ownership
-              RDATA(rb_rnd)->dfree = 0;
-              if (Grid_Cell_Renderer_Value_Map.count(wx_rnd) == 0)
+              if (!is_marker_registered)
+              {
+                wxRuby_RegisterTrackingCategory(WXRUBY_GRID_CELL_RENDERER, wxRuby_markGridCellRenderer, true);
+                is_marker_registered = true;
+              }
+ 
+              // see if this renderer is already tracked 
+              if (wxRuby_FindCategoryValue(WXRUBY_GRID_CELL_RENDERER, wx_rnd) == Qnil)
               {
-          #ifdef __WXRB_DEBUG__
-                if (wxRuby_TraceLevel()>1)
-                  std::wcout << "** wxRuby_RegisterGridCellRenderer : registering " << wx_rnd << ":" << (void*)rb_rnd << std::endl;
-          #endif
+                WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellRenderer, 2)
+                  WXRUBY_TRACE("| wxRuby_RegisterGridCellRenderer : installing monitor")
+                WXRUBY_TRACE_END
+
+                // either a new Ruby created instance or an unwrapped C++ created instance 
+                // always disown; wxWidgets takes over or keeps ownership of reference count
+                RDATA(rb_rnd)->dfree = 0;
+
                 wx_rnd->SetClientObject(new WXRBGridCellRendererMonitor(wx_rnd, rb_rnd));
               }
+              else  // already registered; will be disowned already
+              {
+                // increase the reference count for C++ to take over
+                wx_rnd->IncRef();
+              }
             }
-          }
 
-          // define the grid cell renderer marker
-          static void wxRuby_markGridCellRenderer()
-          {
-            WXRBGridCellRendererValueHash::iterator it;
-            for( it = Grid_Cell_Renderer_Value_Map.begin(); it != Grid_Cell_Renderer_Value_Map.end(); ++it )
-            {
-              VALUE obj = it->second;
-              rb_gc_mark(obj);
-            }
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackGridCellRenderer, 2)
+              WXRUBY_TRACE("< wxRuby_RegisterGridCellRenderer : " << wx_rnd)
+            WXRUBY_TRACE_END
           }
 
           __HEREDOC
-        # register the markers at module initialization
-        spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markGridCellAttr);',
-                           'wxRuby_AppendMarker(wxRuby_markGridCellEditor);',
-                           'wxRuby_AppendMarker(wxRuby_markGridCellRenderer);'
         # add type mappings to handle registration
         # first declare 'normal' type mapping for const pointer (for DrawCellHighlight)
         spec.map 'const wxGridCellAttr *'  => 'Wx::GRID::GridCellAttr' do
@@ -527,10 +631,20 @@ module WXRuby3
             $result = wxRuby_GridCellAttrInstance($1); // check for already registered instance
             if (NIL_P($result))
             {
-              // created by wxWidgets itself
-              // convert and register
+              // As this editor was created in C++ it seems we have no registration yet
+              // but the reference counter will be at least 2 now (1 for C++ owner and 1
+              // increment for returning to us).
+              // We will now register a new Ruby object, keep it disowned and decrement
+              // for now. If passing to C++ again we will increment there.     
               $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), SWIGTYPE_p_wxGridCellAttr, 0);
               wxRuby_RegisterGridCellAttr($1, $result);
+              $1->DecRef();
+            }
+            else
+            {
+              // as this cell attr got passed from C++ it wll have incremented it's reference counter
+              // decrease that here; if we pass it back to C++ we will increase there
+              $1->DecRef();
             }
             __CODE
           map_check code: 'wxRuby_RegisterGridCellAttr($1, argv[$argnum-2]);'

data/rakelib/lib/director/help_controller.rb

@@ -21,15 +21,20 @@ module WXRuby3
         spec.rename_for_ruby('Init' => "#{spec.module_name}::Initialize")
         # ignore these (pure virtual) decls
         spec.ignore %w[
+          wxHelpControllerBase::DisplayContents
           wxHelpControllerBase::DisplayBlock
           wxHelpControllerBase::DisplaySection
+          wxHelpControllerBase::KeywordSearch
           wxHelpControllerBase::LoadFile
           wxHelpControllerBase::Quit
-          ]
+          ], ignore_doc: false
         # and add them as the implemented overrides they are
         spec.extend_interface spec.module_name,
+                              'virtual bool DisplayContents()',
                               'virtual bool DisplayBlock(long blockNo)',
                               'virtual bool DisplaySection(int sectionNo)',
+                              'virtual bool DisplaySection(const wxString &section)',
+                              'virtual bool KeywordSearch(const wxString &keyWord, wxHelpSearchMode mode=wxHELP_SEARCH_ALL)',
                               'virtual bool LoadFile(const wxString &file=wxEmptyString)',
                               'virtual bool Quit()'
         # ignore this problematic method
@@ -62,11 +67,74 @@ module WXRuby3
           spec.ignore 'wxHtmlHelpController::CreateHelpFrame',
                       'wxHtmlHelpController::CreateHelpDialog',
                       'wxHtmlHelpController::GetFrame',
-                      'wxHtmlHelpController::GetDialog'
+                      'wxHtmlHelpController::GetDialog',
+                      'wxHtmlHelpController::DisplayContents',
+                      'wxHtmlHelpController::KeywordSearch'
+          # add custom implementation of HtmlModalHelp as module function (not a class)
+          spec.add_header_code <<~__CODE
+            static VALUE wxruby_HtmlModalHelp(int argc, VALUE *argv, VALUE self)
+            {
+              if (argc < 2 || argc > 4)
+              {
+                rb_raise(rb_eArgError, "wrong # of arguments %d for 2 (max 4)", argc);
+                return Qnil;
+              }
+
+              void *ptr = nullptr;
+              wxWindow *parent = nullptr;
+              wxString help_file;
+              wxString topic = wxEmptyString;
+              int style = wxHF_DEFAULT_STYLE;
+              int res = 0;
+            
+              res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0);
+              if (!SWIG_IsOK(res)) 
+              {
+                VALUE msg = rb_inspect(argv[0]);
+                rb_raise(rb_eTypeError, "expected wxWindow* for 1 but got %s", StringValuePtr(msg));
+                return Qnil; 
+              }
+              parent = reinterpret_cast< wxWindow * >(ptr);
+              if (TYPE(argv[1]) != T_STRING)  
+              {
+                VALUE msg = rb_inspect(argv[1]);
+                rb_raise(rb_eTypeError, "expected String for 2 but got %s", StringValuePtr(msg));
+                return Qnil;
+              }
+              help_file = RSTR_TO_WXSTR(argv[1]);
+              if (argc > 2)
+              {
+                if (TYPE(argv[2]) != T_STRING)  
+                {
+                  VALUE msg = rb_inspect(argv[2]);
+                  rb_raise(rb_eTypeError, "expected String for 3 but got %s", StringValuePtr(msg));
+                  return Qnil;
+                }
+                topic = RSTR_TO_WXSTR(argv[2]);
+              }
+              if (argc > 3)
+              {
+                if (TYPE(argv[3]) != T_FIXNUM)  
+                {
+                  VALUE msg = rb_inspect(argv[3]);
+                  rb_raise(rb_eTypeError, "expected Integer for 4 but got %s", StringValuePtr(msg));
+                  return Qnil;
+                }
+                style = NUM2INT(argv[3]);
+              } 
+              wxHtmlModalHelp(parent, help_file, topic, style);
+              return Qnil;
+            } 
+            __CODE
+          spec.add_init_code <<~__CODE__
+            rb_define_module_function(mWxHtmlHelpController, "HtmlModalHelp", VALUEFUNC(wxruby_HtmlModalHelp), -1);
+            __CODE__
         elsif spec.module_name == 'wxExtHelpController'
           spec.ignore %w[
+            wxExtHelpController::DisplayContents
             wxExtHelpController::DisplayBlock
             wxExtHelpController::DisplaySection
+            wxExtHelpController::KeywordSearch
             wxExtHelpController::LoadFile
             wxExtHelpController::Quit
             wxExtHelpController::GetFrameParameters

data/rakelib/lib/director/help_provider.rb

@@ -92,7 +92,7 @@ module WXRuby3
             // virtual wxString GetHelp(const wxWindowBase* window);
             void RemoveHelp(wxWindowBase* window); // no virtual as we have fixed director impl above
             virtual bool ShowHelp(wxWindowBase* window);
-            virtual bool ShowHelpAtPoint(wxWindowBase* window, const wxPoint point, 
+            virtual bool ShowHelpAtPoint(wxWindowBase* window, const wxPoint& point, 
                                          wxHelpEvent::Origin origin);
           };
           __HEREDOC

data/rakelib/lib/director/html_listbox.rb

@@ -18,8 +18,11 @@ module WXRuby3
 
       def setup
         spec.items << 'wxSimpleHtmlListBox' << 'wxItemContainer'
+        spec.gc_as_window('wxHtmlListBox', 'wxSimpleHtmlListBox')
         super
-        if Config.instance.wx_version_check('3.3.0') > 0
+        if Config.instance.wx_version_check('3.3.1') > 0
+          spec.override_inheritance_chain('wxHtmlListBox', ['wxVListBox', 'wxVScrolledCanvas', 'wxWindow', 'wxEvtHandler', 'wxObject'])
+        elsif Config.instance.wx_version_check('3.3.0') > 0
           spec.override_inheritance_chain('wxHtmlListBox', ['wxVListBox', 'wxVScrolledWindow', 'wxPanel', 'wxWindow', 'wxEvtHandler', 'wxObject'])
         else
           spec.override_inheritance_chain('wxHtmlListBox', ['wxVListBox', { 'wxVScrolledWindow' => 'wxHScrolledWindow' }, 'wxPanel', 'wxWindow', 'wxEvtHandler', 'wxObject'])
@@ -59,6 +62,13 @@ module WXRuby3
                     'wxHtmlListBox::GetSelectedTextColour',
                     'wxHtmlListBox::GetSelectedTextBgColour',
                     'wxHtmlListBox::OnLinkClicked'
+        # missing from the XML docs
+        spec.extend_interface('wxHtmlListBox',
+                              'virtual void OnInternalIdle()',
+                              'virtual void RefreshRow(size_t line)',
+                              'virtual void RefreshRows(size_t from, size_t to)',
+                              'virtual void RefreshAll()',
+                              'virtual void SetItemCount(size_t count)')
         # add missing protected overloads
         spec.extend_interface 'wxHtmlListBox',
                               'virtual void OnDrawItem(wxDC &dc, const wxRect &rect, size_t n) const',
@@ -71,7 +81,9 @@ module WXRuby3
                       'wxHtmlListBox::OnGetRowsHeightHint'
 
         # override inheritance chain
-        if Config.instance.wx_version_check('3.3.0') > 0
+        if Config.instance.wx_version_check('3.3.1') > 0
+          spec.override_inheritance_chain('wxSimpleHtmlListBox', ['wxHtmlListBox', 'wxVListBox', 'wxVScrolledCanvas', 'wxWindow', 'wxEvtHandler', 'wxObject'])
+        elsif Config.instance.wx_version_check('3.3.0') > 0
           spec.override_inheritance_chain('wxSimpleHtmlListBox', ['wxHtmlListBox', 'wxVListBox', 'wxVScrolledWindow', 'wxPanel', 'wxWindow', 'wxEvtHandler', 'wxObject'])
         else
           spec.override_inheritance_chain('wxSimpleHtmlListBox', ['wxHtmlListBox', 'wxVListBox', { 'wxVScrolledWindow' => 'wxHScrolledWindow' }, 'wxPanel', 'wxWindow', 'wxEvtHandler', 'wxObject'])
@@ -84,7 +96,8 @@ module WXRuby3
         # add missing overloads
         spec.extend_interface 'wxSimpleHtmlListBox',
                               'virtual wxString GetString(unsigned int n) const',
-                              'virtual void SetString(unsigned int n, const wxString &string)'
+                              'virtual void SetString(unsigned int n, const wxString &string)',
+                              'wxArrayString GetStrings() const'
         spec.ignore([ 'wxItemContainer::Append(const wxString &, void *)',
                       'wxItemContainer::Append(const std::vector< wxString > &)',
                       'wxItemContainer::Append(const wxArrayString &, void **)',