wxruby3 1.7.0 → 1.8.0

data/rakelib/lib/director/menu.rb

@@ -13,23 +13,47 @@ module WXRuby3
     class Menu < Director
 
       def setup
-        spec.gc_as_object
+        spec.gc_as_marked
         spec.ignore 'wxMenu::wxMenu(long)'
         spec.no_proxy 'wxMenu'  # do not support derived wxMenu classes
         spec.add_header_code <<~__HEREDOC
+          static void GC_mark_wxMenu(const TGCTrackingValueMap& values);
+
           // Custom subclass implementation. 
           // Provides proper support for Ruby GC in destructor.
           class wxRubyMenu : public wxMenu
           {
           public:
+            static const std::string TRACKING_CAT;
+
             wxRubyMenu() : wxMenu() {}
             wxRubyMenu(const wxString &title, long style=0) : wxMenu(title, style) {}
             virtual ~wxRubyMenu()
             {
-              SWIG_RubyUnlinkObjects(this);
-              SWIG_RubyRemoveTracking(this);
+              wxRuby_ReleaseEvtHandlerProcs(this); 
+              wxruby_unregister();
+            }
+
+            void wxruby_register(VALUE rb_menu)
+            {
+              if (!is_registered_)
+              {
+                wxRuby_RegisterTrackingCategory(TRACKING_CAT, GC_mark_wxMenu, true);
+                is_registered_ = true;
+              }
+              if (RB_NIL_P(wxRuby_FindCategoryValue(TRACKING_CAT, this)))
+                wxRuby_RegisterCategoryValue(TRACKING_CAT, this, rb_menu);
+            }
+          private:
+            static bool is_registered_;
+            void wxruby_unregister()
+            {
+              wxRuby_UnregisterCategoryValue(TRACKING_CAT, this);
             }
           };
+
+          const std::string wxRubyMenu::TRACKING_CAT = { "WXRUBY_MENU" };
+          bool wxRubyMenu::is_registered_ {};
         __HEREDOC
         # make Ruby director and wrappers use custom implementation
         spec.use_class_implementation('wxMenu', 'wxRubyMenu')
@@ -63,8 +87,7 @@ module WXRuby3
         spec.map 'wxMenu **' => 'Wx::Menu' do
           map_in ignore: true, temp: 'wxMenu *tmp', code: '$1 = &tmp;'
           map_argout code: <<~__CODE
-            void *ptr = tmp$argnum;
-            $result = SWIG_Ruby_AppendOutput($result, SWIG_NewPointerObj(ptr, SWIGTYPE_p_wxMenu, 0));
+            $result = SWIG_Ruby_AppendOutput($result, wxRuby_WrapWxMenuInRuby(tmp$argnum));
             __CODE
         end
         # for FindChildItem
@@ -75,56 +98,83 @@ module WXRuby3
           // forward decl
           SWIGINTERN void free_wxMenu(void *self);
 
+          static void _gc_mark_single_wxMenu(wxMenu *wx_menu, VALUE rb_menu)
+          {
+            WXRUBY_TRACE_IF(WxRubyTraceMarkMenu, 2)
+              WXRUBY_TRACE("> GC_mark_attached_wxMenu : " << wx_menu)
+            WXRUBY_TRACE_END
+          
+            rb_gc_mark(rb_menu);
+          
+            wxMenuItemList wx_menu_items = wx_menu->GetMenuItems();
+            wxMenuItemList::iterator iter;
+            for (iter = wx_menu_items.begin(); iter != wx_menu_items.end(); ++iter)
+            {
+              wxMenuItem *wx_item = *iter;
+              rb_gc_mark(SWIG_RubyInstanceFor(wx_item) );
+              wxMenu* wx_sub_menu = wx_item->GetSubMenu();
+              if (wx_sub_menu)
+              {
+                VALUE rb_sub_menu = wxRuby_FindCategoryValue(wxRubyMenu::TRACKING_CAT, wx_sub_menu);
+                _gc_mark_single_wxMenu(wx_sub_menu, rb_sub_menu);
+              }
+            }
+          
+            WXRUBY_TRACE_IF(WxRubyTraceMarkMenu, 2)
+              WXRUBY_TRACE("< GC_mark_attached_wxMenu : " << wx_menu)
+            WXRUBY_TRACE_END
+          }
+
           // Mark Function
           // Need to protect MenuItems which are included in the Menu, including
           // their associated sub-menus, recursively.
-          static void GC_mark_wxMenu(void *ptr) 
+          static void GC_mark_wxMenu(const TGCTrackingValueMap& values) 
           {
             WXRUBY_TRACE_IF(WxRubyTraceMarkMenu, 2)
-              WXRUBY_TRACE("> GC_mark_wxMenu : " << ptr)
+              WXRUBY_TRACE("> GC_mark_wxMenu")
             WXRUBY_TRACE_END
-        
-            VALUE rb_menu = SWIG_RubyInstanceFor(ptr);
-            if (!RB_NIL_P(rb_menu))
+
+            for (const auto& ti : values)
             {
-              // as long as the dfree function is still the managed free function the menu has not been attached to a menu bar
-              // but it may hay have already had submenus and/or menuitems added which need to be marked
-              if (RDATA(rb_menu)->dfree == free_wxMenu)
-              {
-                wxMenu* wx_menu = static_cast<wxMenu*> (ptr);
+              _gc_mark_single_wxMenu(static_cast<wxMenu*> (ti.first), ti.second);
+            }
           
-                wxMenuItemList wx_menu_items = wx_menu->GetMenuItems();
-                wxMenuItemList::iterator iter;
-                for (iter = wx_menu_items.begin(); iter != wx_menu_items.end(); ++iter)
+            WXRUBY_TRACE_IF(WxRubyTraceMarkMenu, 2)
+              WXRUBY_TRACE("< GC_mark_wxMenu")
+            WXRUBY_TRACE_END
+          }
+
+          WXRUBY_EXPORT VALUE wxRuby_WrapWxMenuInRuby(wxMenu* wx_menu)
+          {
+            VALUE rb_menu = Qnil;
+            if (wx_menu)
+            {
+              rb_menu = wxRuby_FindCategoryValue(wxRubyMenu::TRACKING_CAT, wx_menu); // check for already registered instance
+              if (NIL_P(rb_menu))
+              {
+                // newly created
+                wxRubyMenu* wxrb_menu = dynamic_cast<wxRubyMenu*> (wx_menu);
+                if (wxrb_menu)
                 {
-                  wxMenuItem *wx_item = *iter;
-                  rb_gc_mark( SWIG_RubyInstanceFor(wx_item) ); 
-                  wxMenu* wx_sub_menu = wx_item->GetSubMenu();
-                  if (wx_sub_menu)
-                    GC_mark_attached_wxMenu(wx_sub_menu);
+                  // convert and own
+                  rb_menu = SWIG_NewPointerObj(SWIG_as_voidptr(wxrb_menu), SWIGTYPE_p_wxMenu, SWIG_POINTER_OWN);
+                  wxrb_menu->wxruby_register(rb_menu);
+                }
+                else
+                {
+                  // created internally by wxWidgets; no tracking and no ownership
+                  rb_menu = SWIG_NewPointerObj(SWIG_as_voidptr(wx_menu), SWIGTYPE_p_wxMenu, 0);
                 }
-              }
-              else // otherwise the menu has been attached to a menu bar and may already have been deleted (or not)
-              {    // marking in this case will be left to the menu bar
-                WXRUBY_TRACE_IF(WxRubyTraceMarkMenu, 3)
-                  WXRUBY_TRACE("< GC_mark_wxMenu : skipping attached menu")
-                WXRUBY_TRACE_END
               }
             }
-            else
-            {
-              WXRUBY_TRACE_IF(WxRubyTraceMarkMenu, 3)
-                WXRUBY_TRACE("< GC_mark_wxMenu : skipping untracked menu (should not have happened)")
-              WXRUBY_TRACE_END
-            } 
-          
-            WXRUBY_TRACE_IF(WxRubyTraceMarkMenu, 2)
-              WXRUBY_TRACE("< GC_mark_wxMenu : " << ptr)
-            WXRUBY_TRACE_END
+            return rb_menu;
+          }
+
+          WXRUBY_EXPORT void wxRuby_RegisterWxMenu(wxMenu* wx_menu, VALUE rb_menu)
+          {
+            wxRubyMenu* wxrb_menu = dynamic_cast<wxRubyMenu*> (wx_menu);
+            if (wxrb_menu) wxrb_menu->wxruby_register(rb_menu);              
           }
-        __HEREDOC
-        spec.add_swig_code <<~__HEREDOC
-          %markfunc wxMenu "GC_mark_wxMenu";
         __HEREDOC
         # ignore MSW specific method
         spec.ignore 'wxMenu::MSWCommand'

data/rakelib/lib/director/menu_bar.rb

@@ -16,7 +16,7 @@ module WXRuby3
 
       def setup
         super
-        spec.gc_as_object # not a typical window
+        spec.gc_as_marked # not a typical window
         spec.no_proxy('wxMenuBar::FindItem',
                 'wxMenuBar::Remove',
                 'wxMenuBar::Replace')
@@ -28,71 +28,110 @@ module WXRuby3
         spec.new_object 'wxMenuBar::Remove', 'wxMenuBar::Replace'
         # for FindItem
         spec.map 'wxMenu **' => 'Wx::Menu' do
+          add_header_code 'WXRUBY_EXPORT VALUE wxRuby_WrapWxMenuInRuby(wxMenu* wx_menu);'
           map_in ignore: true, temp: 'wxMenu *tmp', code: '$1 = &tmp;'
           map_argout code: <<~__CODE
-            void *ptr = tmp$argnum;
-            $result = SWIG_Ruby_AppendOutput($result, SWIG_NewPointerObj(ptr, SWIGTYPE_p_wxMenu, 0));
+            $result = SWIG_Ruby_AppendOutput($result, wxRuby_WrapWxMenuInRuby(tmp$argnum));
             __CODE
         end
         spec.add_header_code <<~__HEREDOC
-          WXRUBY_TRACE_GUARD(WxRubyTraceMarkMenubar, "GC_MARK_MENUBAR")
+          static void GC_mark_wxMenuBar(const TGCTrackingValueMap& values);
+
+          // Custom subclass implementation. 
+          // Provides support for monitored tracking and  GC handling.
+          class wxRubyMenuBar : public wxMenuBar
+          {
+          public:
+            static const std::string TRACKING_CAT;
 
-          // forward decl
-          SWIGINTERN void free_wxMenuBar(void *self);
+            wxRubyMenuBar(long style=0) : wxMenuBar(style) {} 
+            virtual ~wxRubyMenuBar()
+            {
+              wxRuby_ReleaseEvtHandlerProcs(this); 
+              wxruby_unregister();              
+            }
+
+            void wxruby_register(VALUE rb_menubar)
+            {
+              if (!is_registered_)
+              {
+                wxRuby_RegisterTrackingCategory(TRACKING_CAT, GC_mark_wxMenuBar, true);
+                is_registered_ = true;
+              }
+              if (RB_NIL_P(wxRuby_FindCategoryValue(TRACKING_CAT, this)))
+                wxRuby_RegisterCategoryValue(TRACKING_CAT, this, rb_menubar);
+            }
+          private:
+            static bool is_registered_;
+            void wxruby_unregister()
+            {
+              wxRuby_UnregisterCategoryValue(TRACKING_CAT, this);
+            }
+          };
+
+          const std::string wxRubyMenuBar::TRACKING_CAT = { "WXRUBY_MENU_BAR" };
+          bool wxRubyMenuBar::is_registered_ {};
+
+          WXRUBY_TRACE_GUARD(WxRubyTraceMarkMenubar, "GC_MARK_MENUBAR")
 
           // Mark Function for unattached menu bars
           // Need to protect Menu and MenuItems which are included in the MenuBar
-          static void GC_mark_wxMenuBar(void *ptr) 
+          static void GC_mark_wxMenuBar(const TGCTrackingValueMap& values)
           {
             WXRUBY_TRACE_IF(WxRubyTraceMarkMenubar, 2)
-              WXRUBY_TRACE("> GC_mark_wxMenuBar : " << ptr)
+              WXRUBY_TRACE("> GC_mark_wxMenuBar")
             WXRUBY_TRACE_END
           
-            VALUE rb_menu_bar = SWIG_RubyInstanceFor(ptr);
-            if (!RB_NIL_P(rb_menu_bar))
+            for (const auto& ti : values)
             {
-              // as long as the dfree function is still the managed free function the menubar has not been attached to a window
-              // but it may hay have already had menus and/or menuitems added which need to be marked
-              if (RDATA(rb_menu_bar)->dfree == free_wxMenuBar)
-              {
-                // Menu bars are also a subclass of wxWindow, so must do all the marking
-                // of sizers and carets associated with that class
-                GC_mark_wxWindow(ptr);
+              rb_gc_mark(ti.second);
+
+              // Menu bars are also a subclass of wxWindow, so must do all the marking
+              // of sizers and carets associated with that class
+              GC_mark_wxWindow(ti.first);
 
-                wxMenuBar* wx_menu_bar = static_cast<wxMenuBar*> (ptr);
+              // no need to mark anything else as menus are tracked themselves separately
+            }
           
-                WXRUBY_TRACE_IF(WxRubyTraceMarkMenubar, 3)
-                  WXRUBY_TRACE("< GC_mark_wxMenuBar : marking " << wx_menu_bar->GetMenuCount() << " menus")
-                WXRUBY_TRACE_END
-            
-                // Mark each menu in the menubar in turn
-                for ( size_t i = 0; i < wx_menu_bar->GetMenuCount(); i++ )
+            WXRUBY_TRACE_IF(WxRubyTraceMarkMenubar, 2)
+              WXRUBY_TRACE("< GC_mark_wxMenuBar")
+            WXRUBY_TRACE_END
+          }
+
+          WXRUBY_EXPORT VALUE wxRuby_WrapWxMenuBarInRuby(wxMenuBar* wx_menubar)
+          {
+            VALUE rb_menubar = Qnil;
+            if (wx_menubar)
+            {   
+              rb_menubar = wxRuby_FindCategoryValue(wxRubyMenuBar::TRACKING_CAT, wx_menubar); // check for already registered instance
+              if (NIL_P(rb_menubar))
+              {
+                // newly created
+                wxRubyMenuBar* wxrb_mb = dynamic_cast<wxRubyMenuBar*> (wx_menubar);
+                if (wxrb_mb)
                 {
-                  GC_mark_attached_wxMenu(wx_menu_bar->GetMenu(i));
+                  // convert and own
+                  rb_menubar = SWIG_NewPointerObj(SWIG_as_voidptr(wxrb_mb), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_OWN);
+                  wxrb_mb->wxruby_register(rb_menubar);
+                }
+                else
+                {
+                  // created internally by wxWidgets; no tracking and no ownership
+                  rb_menubar = SWIG_NewPointerObj(SWIG_as_voidptr(wx_menubar), SWIGTYPE_p_wxMenuBar, 0);
                 }
-              }
-              else // otherwise the menu bar has been attached to a frame and may already have been deleted (or not)
-              {    // marking in this case will be left to the frame
-                WXRUBY_TRACE_IF(WxRubyTraceMarkMenubar, 3)
-                  WXRUBY_TRACE("< GC_mark_wxMenuBar : skipping attached menu bar")
-                WXRUBY_TRACE_END
               }
             }
-            else
-            {
-              WXRUBY_TRACE_IF(WxRubyTraceMarkMenubar, 3)
-                WXRUBY_TRACE("< GC_mark_wxMenuBar : skipping untracked menu bar (should not have happened)")
-              WXRUBY_TRACE_END
-            } 
-          
-            WXRUBY_TRACE_IF(WxRubyTraceMarkMenubar, 2)
-              WXRUBY_TRACE("< GC_mark_wxMenuBar : " << ptr)
-            WXRUBY_TRACE_END
+            return rb_menubar;
+          }
+
+          WXRUBY_EXPORT void wxRuby_RegisterWxMenuBar(wxMenuBar* wx_menubar, VALUE rb_menubar)
+          {
+            wxRubyMenuBar* wxrb_mb = dynamic_cast<wxRubyMenuBar*> (wx_menubar);
+            if (wxrb_mb) wxrb_mb->wxruby_register(rb_menubar);              
           }
-        __HEREDOC
-        spec.add_swig_code <<~__HEREDOC
-          %markfunc wxMenu "GC_mark_wxMenuBar";
-        __HEREDOC
+          __HEREDOC
+        # make Ruby director and wrappers use custom implementation
+        spec.use_class_implementation('wxMenuBar', 'wxRubyMenuBar')
       end
     end # class MenuBar
 

data/rakelib/lib/director/menu_item.rb

@@ -24,8 +24,8 @@ module WXRuby3
         spec.ignore(%w[wxMenuItem::GetLabel wxMenuItem::GetName wxMenuItem::GetText wxMenuItem::SetText wxMenuItem::GetLabelFromText])
         # Replace for more specific param naming
         spec.ignore 'wxMenuItem::SetSubMenu(wxMenu *)', ignore_doc: false
-        spec.extend_interface 'wxMenuItem', 'void SetSubMenu(wxMenu *sub_menu)'
-        spec.disown 'wxMenu *sub_menu'
+        spec.extend_interface 'wxMenuItem', 'void SetSubMenu(wxMenu *subMenu)'
+        spec.disown 'wxMenu *subMenu'
         # ignore this as there is no implementation anymore
         spec.ignore 'wxMenuItem::GetAccelFromString'
         spec.ignore_unless('USE_ACCEL', 'wxMenuItem::GetAccel')

data/rakelib/lib/director/persistence_manager.rb

@@ -200,7 +200,7 @@ module WXRuby3
             }
           }
 
-          static void wxRuby_markPersistentObjects()
+          static void wxRuby_markPersistentObjects(const TGCTrackingValueMap& /*unused*/)
           {
             WxRubyPersistenceManager* wxrb_pm = 
               dynamic_cast<WxRubyPersistenceManager*> (&wxPersistenceManager::Get());
@@ -399,7 +399,8 @@ module WXRuby3
           // install the default global wxRuby persistence manager
           wxPersistenceManager::Set(s_wxruby_persistence_manager);
           // and the persistent object marker
-          wxRuby_AppendMarker(wxRuby_markPersistentObjects);
+          static const std::string WXRUBY_PERSISTENT_OBJECTS = {"WXRUBY_PERSISTENT_OBJECTS"};
+          wxRuby_RegisterTrackingCategory(WXRUBY_PERSISTENT_OBJECTS, wxRuby_markPersistentObjects);
           __HEREDOC
       end
 

data/rakelib/lib/director/preview_frame.rb

@@ -53,8 +53,8 @@ module WXRuby3
             if ( GC_IsWindowDeleted(ptr) )
               return;
         
-            // Do standard marking routines as for all wxFrames
-            GC_mark_wxFrame(ptr);
+            // Do standard marking routines as for all windows
+            GC_mark_wxWindow(ptr);
 
             WxRubyPreviewFrame* preview_frame = dynamic_cast<WxRubyPreviewFrame*>((wxPreviewFrame*)ptr);
             if (preview_frame)

data/rakelib/lib/director/richtext_buffer.rb

@@ -102,7 +102,7 @@ module WXRuby3
           __HEREDOC
         spec.add_header_code <<~__HEREDOC
           // define the richtext buffer marker
-          static void wxRuby_markRichTextBuffer()
+          static void wxRuby_markRichTextBuffer(const TGCTrackingValueMap& /*unused*/)
           {
             // mark any user installed drawing handlers
             wxList& handlers = wxRichTextBuffer::GetDrawingHandlers();
@@ -125,7 +125,10 @@ module WXRuby3
           }
           __HEREDOC
         # register the marker at module initialization
-        spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markRichTextBuffer);'
+        spec.add_init_code <<~__HEREDOC
+          const std::string WXRUBY_RICHTEXT_BUFFER = {"WXRUBY_RICHTEXT_BUFFER"};
+          wxRuby_RegisterTrackingCategory(WXRUBY_RICHTEXT_BUFFER, wxRuby_markRichTextBuffer);
+          __HEREDOC
         # for GetExtWildcard
         spec.map 'wxArrayInt* types' => 'Array,nil' do
 

data/rakelib/lib/director/shared_evt_handler.rb

@@ -0,0 +1,30 @@
+# 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 SharedEvtHandler < Director
+
+      def setup
+        super
+        spec.items.clear
+        spec.add_header_code <<~__HEREDOC
+          #include "wxruby-SharedEventHandler.h"
+          __HEREDOC
+        spec.add_init_code <<~__HEREDOC
+          wx_setup_WxRubySharedEvtHandler(mWxRT);
+          __HEREDOC
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/director/sizer.rb

@@ -56,11 +56,10 @@ module WXRuby3
             {
               if ($self->Detach(szr))
               {
-                VALUE rb_szr = SWIG_RubyInstanceFor(szr);
-                if (rb_szr && !NIL_P(rb_szr))
+                if (!RB_NIL_P(SWIG_RubyInstanceFor(szr)))
                 {
-                  // transfer ownership to Ruby
-                  RDATA(rb_szr)->dfree = GcSizerFreeFunc;            
+                  // have SWIG transfer ownership of Ruby value       
+                  SWIG_NewPointerObj(szr, SWIGTYPE_p_wxSizer, SWIG_POINTER_OWN);
                 }
                 return true;
               }
@@ -72,20 +71,12 @@ module WXRuby3
               wxSizerItem* itm = $self->GetItem(itm_nr);
               if (itm)
               {
-                VALUE rb_szr = Qnil;
-                if (itm->IsSizer())
-                {
-                  rb_szr = SWIG_RubyInstanceFor(itm->GetSizer());
-                }
-                if ($self->Detach(itm_nr))
-                {
-                  if (rb_szr && !NIL_P(rb_szr))
-                  {
-                    // transfer ownership to Ruby
-                    RDATA(rb_szr)->dfree = GcSizerFreeFunc;            
-                  }
-                  return true;
+                if (itm->IsSizer() && !RB_NIL_P(SWIG_RubyInstanceFor(itm->GetSizer())))
+                { 
+                  // have SWIG transfer ownership of Ruby value       
+                  SWIG_NewPointerObj(itm->GetSizer(), SWIGTYPE_p_wxSizer, SWIG_POINTER_OWN);
                 }
+                return $self->Detach(itm_nr);
               }
               return false;
             }

data/rakelib/lib/director/sizer_item.rb

@@ -46,11 +46,10 @@ module WXRuby3
             {
               if ($self->IsSizer())
               {
-                VALUE rb_szr = SWIG_RubyInstanceFor($self->GetSizer());
-                if (rb_szr && !NIL_P(rb_szr))
+                if (!RB_NIL_P(SWIG_RubyInstanceFor($self->GetSizer())))
                 {
-                  // transfer ownership to Ruby
-                  RDATA(rb_szr)->dfree = GcSizerFreeFunc;            
+                  // have SWIG transfer ownership of Ruby value       
+                  SWIG_NewPointerObj($self->GetSizer(), SWIGTYPE_p_wxSizer, SWIG_POINTER_OWN);
                 }
                 $self->DetachSizer();
               }              

data/rakelib/lib/director/task_bar_icon.rb

@@ -42,16 +42,16 @@ module WXRuby3
         # overridden in user subclasses of TaskBarIcon to provide the menu over the icon.
         # In the case of GetPopupMenu the menu will be used but not deleted so it can be stored in
         # a member variable and reused.
-        # In the case of CreatePopupMenu the menu is disowned and deleted of use. The Wx::Menu Ruby
-        # instance than needs to be protected from GC so the typemap stores the
-        # object returned by the ruby method in an instance variable so it's
-        # marked. It also handles the special case where +nil+ is returned, to
-        # signal to Wx that no menu is to be shown.
+        # In the case of CreatePopupMenu the menu is disowned and deleted after use. The Wx::Menu Ruby
+        # instance than needs to be protected from GC so the typemap stores the object returned by the
+        # ruby method in an instance variable so it's marked as long as the TaskBarIcon exists.
+        # It also handles the special case where +nil+ is returned, to signal to Wx that no menu is to
+        # be shown.
         spec.map 'wxMenu *' do
           map_directorout code: <<~__CODE
             static const std::string create_popup_menu("CreatePopupMenu");
             bool disown = (std::string("$symname") == create_popup_menu);
-            if (disown) rb_iv_set(swig_get_self(), "@__popmenu__", $1);
+            if (disown) rb_iv_set(swig_get_self(), "@__popupmenu__", $1);
             if (NIL_P($1))
             {
               $result = nullptr;
@@ -65,7 +65,7 @@ module WXRuby3
                 Swig::DirectorTypeMismatchException::raise(swig_get_self(), "$symname", rb_eTypeError,
                          "create_popup_menu must return a Wx::Menu, or nil");
               }
-              $result = reinterpret_cast < wxMenu * > (ptr);
+              $result = static_cast <wxMenu *> (ptr);
             }
             __CODE
         end

data/rakelib/lib/director/thread_event.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+require_relative './event'
+
+module WXRuby3
+
+  class Director
+
+    class ThreadEvent < Event
+
+      def setup
+        super
+        spec.gc_as_marked # use marked so doc gen does not mark it as untracked (what it actually is)
+        spec.ignore 'wxThreadEvent::GetPayload',
+                    'wxThreadEvent::SetPayload',
+                    'wxThreadEvent::GetEventCategory'
+        spec.ignore 'wxThreadEvent::wxThreadEvent'
+        spec.regard 'wxThreadEvent::wxThreadEvent', regard_doc: false
+        spec.add_swig_code %Q{%constant wxEventType wxEVT_THREAD = wxEVT_THREAD;}
+        spec.do_not_generate(:variables, :defines, :enums, :functions)
+      end
+
+    end # class ThreadEvent
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/validator.rb

@@ -54,7 +54,9 @@ module WXRuby3
               VALUE self = const_cast<wxRubyValidator*> (this)->get_self();
               VALUE rc = wxRuby_Funcall(self, clone_id(), 0);
               void *ptr;
-              int res = SWIG_ConvertPtr(rc, &ptr, SWIGTYPE_p_wxValidator,  0);
+              // disown the validator for this is a C++ return and when this is called by a window
+              // to set it's validator that window will manage the validator
+              int res = SWIG_ConvertPtr(rc, &ptr, SWIGTYPE_p_wxValidator,  SWIG_POINTER_DISOWN);
               if (!SWIG_IsOK(res)) 
               {
                 Swig::DirectorTypeMismatchException::raise(self, "clone", SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""Wx::Validator *""'");

data/rakelib/lib/director/variant.rb

@@ -388,25 +388,22 @@ module WXRuby3
           WXRUBY_TRACE_GUARD(WxRubyTraceGCTrackVariant, "GC_TRACK_VARIANT")
 
           class WXRBValueVariantData;
-          // Mapping of WXRBValueVariantData* to Ruby VALUE
-          WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
-                                      WXRBVariantDataToRbValueHash);
-          static WXRBVariantDataToRbValueHash Variant_Value_Map;
 
-          static void GC_mark_RbValueVariants()
+          static const std::string WXRUBY_VARIANT_DATA = { "WXRUBY_VARIANT_DATA" };
+
+          static void GC_mark_RbValueVariants(const TGCTrackingValueMap& values)
           {
             WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
               WXRUBY_TRACE("> GC_mark_RbValueVariants")
             WXRUBY_TRACE_END
 
-            WXRBVariantDataToRbValueHash::iterator it;
-            for( it = Variant_Value_Map.begin(); it != Variant_Value_Map.end(); ++it )
+            for(const auto& ti : values)
             {
-              VALUE obj = it->second;
+              VALUE obj = ti.second;
 
               WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
                 WXRUBY_TRACE_WITH(void *c_ptr = (TYPE(obj) == T_DATA ? DATA_PTR(obj) : 0))
-                WXRUBY_TRACE("| GC_mark_RbValueVariants : " << it->first << "|" << (void*)c_ptr)
+                WXRUBY_TRACE("| GC_mark_RbValueVariants : " << ti.first << "|" << (void*)c_ptr)
               WXRUBY_TRACE_END
 
               rb_gc_mark(obj);
@@ -419,12 +416,20 @@ module WXRuby3
 
           static void wxRuby_RegisterValueVariantData(void* ptr, VALUE rbval)
           {
+            static bool is_marker_registered = false;
+
             WXRUBY_TRACE_IF(WxRubyTraceGCTrackVariant, 2)
               WXRUBY_TRACE_WITH(void *c_ptr = (TYPE(rbval) == T_DATA ? DATA_PTR(rbval) : 0))
               WXRUBY_TRACE("> wxRuby_RegisterValueVariantData : " << ptr << "|" << (void*)c_ptr)
             WXRUBY_TRACE_END
 
-            Variant_Value_Map[ptr] = rbval;
+            if (!is_marker_registered)
+            {
+              wxRuby_RegisterTrackingCategory(WXRUBY_VARIANT_DATA, GC_mark_RbValueVariants, true);
+              is_marker_registered = true;
+            }
+
+            wxRuby_RegisterCategoryValue(WXRUBY_VARIANT_DATA, ptr, rbval);
 
             WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
               WXRUBY_TRACE("< wxRuby_RegisterValueVariantData")
@@ -437,7 +442,7 @@ module WXRuby3
               WXRUBY_TRACE("> wxRuby_UnregisterValueVariantData : " << ptr)
             WXRUBY_TRACE_END
 
-            Variant_Value_Map.erase(ptr);
+            wxRuby_UnregisterCategoryValue(WXRUBY_VARIANT_DATA, ptr);
 
             WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
               WXRUBY_TRACE("< wxRuby_UnregisterValueVariantData")
@@ -502,7 +507,6 @@ module WXRuby3
             return variant;
           }
           __HEREDOC
-        spec.add_init_code 'wxRuby_AppendMarker(GC_mark_RbValueVariants);'
         # ignore GetType (not doc)
         spec.ignore 'wxVariant::GetType', ignore_doc: false
         # replace with custom implementation