wxruby3 1.7.0 → 1.8.0

data/rakelib/lib/director/event_handler.rb

@@ -93,6 +93,21 @@ module WXRuby3
               }
               __CODE
           end
+          spec.add_header_code <<~__HEREDOC
+              // custom subclass for Ruby (derived) instances to cleanup event handler procs on destruction 
+              class wxRubyEvtHandler : public wxEvtHandler
+              {
+              public:
+                wxRubyEvtHandler() : wxEvtHandler() {}
+                virtual ~wxRubyEvtHandler()
+                {
+                  wxRuby_ReleaseEvtHandlerProcs(this); 
+                }
+              };
+          
+            __HEREDOC
+          # make Ruby director and wrappers use custom implementation
+          spec.use_class_implementation('wxEvtHandler', 'wxRubyEvtHandler')
           spec.add_runtime_code <<~__HEREDOC
             WXRUBY_TRACE_GUARD(WxRubyTraceEventHandlers, "EVENTS_HANDLER");
             
@@ -153,33 +168,27 @@ module WXRuby3
             // GC until the EvtHandler object itself is destroyed. So we keep a hash
             // which maps C++ pointer addresses of EvtHandlers to lists of
             // the callback objects created to handle their events.
-            typedef wxVector<wxRbCallback*> EvtHandlerProcList;
-            typedef EvtHandlerProcList* EvtHandlerProcListPtr;
-            WX_DECLARE_VOIDPTR_HASH_MAP(EvtHandlerProcListPtr, PtrToEvtHandlerProcs);
-            PtrToEvtHandlerProcs Evt_Handler_Handlers;
+            #include <set>
+            typedef std::set<wxRbCallback*> TEvtHandlerProcs;
+            typedef std::unordered_map<void*, TEvtHandlerProcs> TPtrToEvtHandlerProcs; 
+            static TPtrToEvtHandlerProcs _s__Evt_Handler_Handlers {};
             
             // Add a proc to the list of protected handler for an EvtHandler object
             void wxRuby_ProtectEvtHandlerProc(void* evt_handler, wxRbCallback* proc_cb) 
             {
-              if (Evt_Handler_Handlers.count(evt_handler) == 0)
-                Evt_Handler_Handlers[evt_handler] = new EvtHandlerProcList();
-              Evt_Handler_Handlers[evt_handler]->push_back(proc_cb);
+              _s__Evt_Handler_Handlers[evt_handler].emplace(proc_cb);
             }
             
             static void wxRuby_ReleaseEvtHandlerProc(void* evt_handler, wxRbCallback* proc_cb) 
             {        
-              if (Evt_Handler_Handlers.count(evt_handler) != 0)
+              auto itevh = _s__Evt_Handler_Handlers.find(evt_handler);
+              if (itevh != _s__Evt_Handler_Handlers.end())
               {
-                EvtHandlerProcList *ehpl = Evt_Handler_Handlers[evt_handler];
-                for (EvtHandlerProcList::iterator itproc = ehpl->begin();
-                     itproc != ehpl->end();
-                     itproc++)
+                auto itproc = itevh->second.find(proc_cb); 
+                if (itproc != itevh->second.end())
                 {
-                  if (proc_cb == (*itproc))
-                  {
-                    ehpl->erase(itproc);
-                    return;
-                  }
+                  itevh->second.erase(itproc);
+                  return;
                 }
               }
             }
@@ -187,16 +196,11 @@ module WXRuby3
             // Called by App's mark function; protect all currently needed procs
             void wxRuby_MarkProtectedEvtHandlerProcs() 
             {
-              PtrToEvtHandlerProcs::iterator it;
-              for( it = Evt_Handler_Handlers.begin(); 
-                   it != Evt_Handler_Handlers.end(); 
-                   ++it )
+              for(const auto& ehp :_s__Evt_Handler_Handlers )
               {
-                for (EvtHandlerProcList::iterator itproc = it->second->begin();
-                     itproc != it->second->end();
-                     itproc++)
+                for (const wxRbCallback* rb_cp : ehp.second)
                 {
-                  rb_gc_mark((*itproc)->m_func);
+                  rb_gc_mark(rb_cp->m_func);
                 }
               }
             }
@@ -206,10 +210,10 @@ module WXRuby3
             // swig/mark_free_impl.i
             WXRUBY_EXPORT void wxRuby_ReleaseEvtHandlerProcs(void* evt_handler) 
             {
-              if (Evt_Handler_Handlers.count(evt_handler) != 0)
+              auto itevh = _s__Evt_Handler_Handlers.find(evt_handler);
+              if (itevh != _s__Evt_Handler_Handlers.end())
               {
-                delete Evt_Handler_Handlers[evt_handler];
-                Evt_Handler_Handlers.erase(evt_handler);
+                _s__Evt_Handler_Handlers.erase(itevh);
               }
             }
 

data/rakelib/lib/director/fs_file.rb

@@ -147,28 +147,34 @@ module WXRuby3
           static WxRuby_ID ios_close_id("close");
 
           // Mapping of wxStreamBase* to Ruby IO VALUE
-          WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
-                                      WXRBStreamBaseToRbValueHash);
-          static WXRBStreamBaseToRbValueHash Stream_Value_Map;
 
-          static void wxRuby_markRbStreams()
+          // tracking category
+          static const std::string WXRUBY_RUBY_IO_STREAMS = {"WXRUBY_RUBY_IO_STREAMS"};
+
+          static void wxRuby_markRbStreams(const TGCTrackingValueMap& values)
           {
-            WXRBStreamBaseToRbValueHash::iterator it;
-            for( it = Stream_Value_Map.begin(); it != Stream_Value_Map.end(); ++it )
+            for(const auto& ti : values)
             {
-              VALUE obj = it->second;
+              VALUE obj = ti.second;
               rb_gc_mark(obj);
             }
           }
 
           static void wxRuby_RegisterStream(void* ptr, VALUE rbval)
           {
-            Stream_Value_Map[ptr] = rbval;
+            static bool is_marker_registered = false;
+
+            if (!is_marker_registered)
+            {
+              wxRuby_RegisterTrackingCategory(WXRUBY_RUBY_IO_STREAMS, wxRuby_markRbStreams);
+              is_marker_registered = true;
+            }
+            wxRuby_RegisterCategoryValue(WXRUBY_RUBY_IO_STREAMS, ptr, rbval); 
           }
 
           static void wxRuby_UnregisterStream(void* ptr)
           {
-            Stream_Value_Map.erase(ptr);
+            wxRuby_UnregisterCategoryValue(WXRUBY_RUBY_IO_STREAMS, ptr);
           }
 
           // Implementation for wxRubyInputStream
@@ -373,7 +379,6 @@ module WXRuby3
             }
           }
           __CODE
-        spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markRbStreams);'
       end
 
       def process(gendoc: false)

data/rakelib/lib/director/functions.rb

@@ -83,6 +83,13 @@ module WXRuby3
             return Qnil;
           }
           
+          // Log a Wx error Message to the current Wx log output and abort
+          static VALUE log_fatal_error(int argc, VALUE *argv, VALUE self)
+          {
+            do_log(wxLOG_FatalError, argc, argv);
+            return Qnil;
+          }
+          
           // Log a Wx low prio Message to the current Wx log output
           static VALUE log_info(int argc, VALUE *argv, VALUE self)
           {
@@ -264,6 +271,7 @@ module WXRuby3
         spec.add_init_code <<~__HEREDOC
           rb_define_module_function(mWxFunctions, "log_generic", VALUEFUNC(log_generic), -1);
           rb_define_module_function(mWxFunctions, "log_info", VALUEFUNC(log_info), -1);
+          rb_define_module_function(mWxFunctions, "log_fatal_error", VALUEFUNC(log_info), -1);
           rb_define_module_function(mWxFunctions, "log_verbose", VALUEFUNC(log_verbose), -1);
           rb_define_module_function(mWxFunctions, "log_message", VALUEFUNC(log_message), -1);
           rb_define_module_function(mWxFunctions, "log_warning", VALUEFUNC(log_warning), -1);

data/rakelib/lib/director/grid_cell_attr.rb

@@ -39,9 +39,7 @@ module WXRuby3
         spec.ignore('wxGridCellAttr::GetEditorPtr',
                     'wxGridCellAttr::GetRendererPtr')
         # these require wxRuby to take ownership (ref counted)
-        spec.new_object('wxGridCellAttr::Clone',
-                        'wxGridCellAttr::GetEditor',
-                        'wxGridCellAttr::GetRenderer')
+        spec.new_object('wxGridCellAttr::Clone')
         # type mapping for wxGridCellEditor* return ref
         spec.map 'wxGridCellEditor*' => 'Wx::GRID::GridCellEditor' do
           add_header_code 'extern VALUE wxRuby_WrapWxGridCellEditorInRuby(const wxGridCellEditor *wx_gce);',

data/rakelib/lib/director/grid_cell_editor.rb

@@ -39,6 +39,9 @@ module WXRuby3
               VALUE rb_gce = wxRuby_GridCellEditorInstance(const_cast<wxGridCellEditor*> (wx_gce));
               if (rb_gce && !NIL_P(rb_gce))
               {
+                // as this editor 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
+                const_cast<wxGridCellEditor*> (wx_gce)->DecRef();
                 return rb_gce;
               }
 
@@ -98,19 +101,24 @@ module WXRuby3
               }
 
               // Otherwise, retrieve the swig type info for this class and wrap it
-              // in Ruby. Make it owned to manage the ref count if GC claims the object. 
+              // in Ruby.
+              // 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.     
               // wxRuby_GetSwigTypeForClass is defined in wx.i
               swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(r_class);
               rb_gce = SWIG_NewPointerObj(const_cast<void*> (ptr), swig_type, 0);
               wxRuby_RegisterGridCellEditor(const_cast<wxGridCellEditor*> (wx_gce), rb_gce);
+              const_cast<wxGridCellEditor*> (wx_gce)->DecRef();
               return rb_gce;
             }
 
             extern void GC_free_GridCellEditor(void *ptr)
             {
-              wxGridCellEditor* gc_edt = (wxGridCellEditor*)ptr; 
-              if (ptr)
-                gc_edt->DecRef();
+              wxGridCellEditor* gc_edt = (wxGridCellEditor*)ptr;
+              wxSafeDecRef(gc_edt);
             }
             __CODE
         elsif spec.module_name == 'wxGridCellActivatableEditor'
@@ -147,7 +155,7 @@ module WXRuby3
             spec.override_inheritance_chain(spec.module_name, %w[wxGridCellEditor])
           end
           # due to the flawed wxWidgets XML docs we need to explicitly add these here
-          # otherwise the derived editors won't be allocable due to pure virtuals
+          # otherwise the derived editors won't be allocatable due to pure virtuals
           spec.extend_interface spec.module_name,
             'void BeginEdit(int row, int col, wxGrid *grid)',
             'wxGridCellEditor * Clone() const',
@@ -157,13 +165,7 @@ module WXRuby3
             'void Reset()',
             'wxString GetValue() const'
         end
-        unless spec.module_name == 'wxGridCellEditor'
-          # type mapping for Clone return ref
-          spec.map 'wxGridCellEditor*' => 'Wx::GRID::GridCellEditor' do
-            add_header_code 'extern VALUE wxRuby_WrapWxGridCellEditorInRuby(const wxGridCellEditor *wx_gce);'
-            map_out code: '$result = wxRuby_WrapWxGridCellEditorInRuby($1);'
-          end
-        end
+        spec.new_object "#{spec.module_name}::Clone"
         # handled; can be suppressed
         spec.suppress_warning(473, "#{spec.module_name}::Clone")
       end

data/rakelib/lib/director/grid_cell_renderer.rb

@@ -38,6 +38,9 @@ module WXRuby3
               VALUE rb_gcr = wxRuby_GridCellRendererInstance(const_cast<wxGridCellRenderer*> (wx_gcr));
               if (rb_gcr && !NIL_P(rb_gcr))
               {
+                // as this renderer 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
+                const_cast<wxGridCellRenderer*> (wx_gcr)->DecRef();
                 return rb_gcr;
               }
 
@@ -94,11 +97,17 @@ module WXRuby3
               }
 
               // Otherwise, retrieve the swig type info for this class and wrap it
-              // in Ruby. Make it owned to manage the ref count if GC claims the object.
+              // in Ruby. 
+              // As this renderer 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.     
               // wxRuby_GetSwigTypeForClass is defined in wx.i
               swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(r_class);
               rb_gcr = SWIG_NewPointerObj(const_cast<void*> (ptr), swig_type, 0);
               wxRuby_RegisterGridCellRenderer(const_cast<wxGridCellRenderer*> (wx_gcr), rb_gcr);
+              const_cast<wxGridCellRenderer*> (wx_gcr)->DecRef();
               return rb_gcr;
             }
 
@@ -126,13 +135,7 @@ module WXRuby3
               'virtual wxSize GetBestSize(wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, int row, int col)'
           spec.force_proxy spec.module_name
         end
-        unless spec.module_name == 'wxGridCellRenderer'
-          # type mapping for Clone return ref
-          spec.map 'wxGridCellRenderer*' => 'Wx::GRID::GridCellRenderer' do
-            add_header_code 'extern VALUE wxRuby_WrapWxGridCellRendererInRuby(const wxGridCellRenderer *wx_gcr);'
-            map_out code: '$result = wxRuby_WrapWxGridCellRendererInRuby($1);'
-          end
-        end
+        spec.new_object "#{spec.module_name}::Clone"
         # handled; can be suppressed
         spec.suppress_warning(473, "#{spec.module_name}::Clone")
       end