wxruby3 0.9.0.pre.beta.11 → 0.9.0.pre.beta.13

data/rakelib/lib/director/data_object.rb

@@ -66,10 +66,10 @@ module WXRuby3
           typedef std::map<wxDataObjectComposite*, data_object_list_t> composite_data_object_map_t;
           static composite_data_object_map_t CompositeDataObject_Map;
 
-          static void wxRuby_markCompositeDataObjects()
+          static void GC_mark_wxCompositeDataObject(void* ptr)
           {
-            composite_data_object_map_t::iterator it;
-            for( it = CompositeDataObject_Map.begin(); it != CompositeDataObject_Map.end(); ++it )
+            composite_data_object_map_t::iterator it = CompositeDataObject_Map.find(static_cast<wxDataObjectComposite*> (ptr));
+            if (it != CompositeDataObject_Map.end())
             {
               data_object_list_t &do_list = it->second;
               for (VALUE data_obj : do_list)
@@ -96,12 +96,80 @@ module WXRuby3
               CompositeDataObject_Map.erase(this);
             } 
           };
+
+          #if wxUSE_RICHTEXT 
+          #include <wx/richtext/richtextbuffer.h>
+          #endif
+
+          // Add custom object wrapper for DataObjectComposite#get_object result
+          static VALUE wxRuby_WrapDataObjectSimple(wxDataObjectSimple* d_obj)
+          {
+            if (!d_obj)
+              return Qnil;
+
+            // check if we have this object tracked
+            VALUE r_obj = SWIG_RubyInstanceFor(d_obj);
+            if (r_obj != Qnil)
+            {
+              swig_class* sklass = (swig_class *) SWIGTYPE_p_wxDataObjectSimple->clientdata;
+              if (rb_obj_is_kind_of(r_obj, sklass->klass))
+                return r_obj; 
+            }      
+            
+            // Otherwise check the returned type and create a new object wrapper
+            void* do_ptr;
+            if ((do_ptr = dynamic_cast<wxBitmapDataObject*> (d_obj)))
+            {
+              return SWIG_NewPointerObj(do_ptr, SWIGTYPE_p_wxBitmapDataObject, 0);
+            }
+            if ((do_ptr = dynamic_cast<wxImageDataObject*> (d_obj)))
+            {
+              return SWIG_NewPointerObj(do_ptr, SWIGTYPE_p_wxImageDataObject, 0);
+            }
+            if ((do_ptr = dynamic_cast<wxCustomDataObject*> (d_obj)))
+            {
+              return SWIG_NewPointerObj(do_ptr, SWIGTYPE_p_wxCustomDataObject, 0);
+            }
+            if ((do_ptr = dynamic_cast<wxFileDataObject*> (d_obj)))
+            {
+              return SWIG_NewPointerObj(do_ptr, SWIGTYPE_p_wxFileDataObject, 0);
+            }
+            if ((do_ptr = dynamic_cast<wxTextDataObject*> (d_obj)))
+            {
+              return SWIG_NewPointerObj(do_ptr, SWIGTYPE_p_wxTextDataObject, 0);
+            }
+          #if wxUSE_HTML && (wxVERSION_NUMBER >= 3300)
+            if ((do_ptr = dynamic_cast<wxHTMLDataObject*> (d_obj)))
+            {
+              VALUE r_class = rb_eval_string("Wx::HTML::HTMLDataObject");
+              swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(r_class);
+              return SWIG_NewPointerObj(do_ptr, swig_type, 0);
+            }
+          #endif
+          /** Leave these for now. RichText has special needs
+          #if wxUSE_RICHTEXT 
+            if ((do_ptr = dynamic_cast<wxRichTextBufferDataObject*> (d_obj)))
+            {
+              VALUE r_class = rb_eval_string("Wx::RTC::RichTextBufferDataObject");
+              swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(r_class);
+              return SWIG_NewPointerObj(do_ptr, swig_type, 0);
+            }
+          #endif
+          **/
+            return SWIG_NewPointerObj(SWIG_as_voidptr(d_obj), SWIGTYPE_p_wxDataObjectSimple, 0);
+          }
           __HEREDOC
         # install GC marker
-        spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markCompositeDataObjects);'
+        spec.add_swig_code '%markfunc wxDataObjectComposite "GC_mark_wxCompositeDataObject";'
+
         # use custom implementation class
         spec.use_class_implementation 'wxDataObjectComposite', 'WxRuby_DataObjectComposite'
 
+        # make sure to return the right derived type
+        spec.map 'wxDataObjectSimple*' => 'Wx::DataObjectSimple' do
+          map_out code: '$result = wxRuby_WrapDataObjectSimple($1);'
+        end
+
         # disable generating the default Add method (keep docs)
         spec.ignore 'wxDataObjectComposite::Add', ignore_doc: false
         # Add custom Add implementation

data/rakelib/lib/director/derived_dc.rb

@@ -14,20 +14,24 @@ module WXRuby3
         spec.disable_proxies
         if spec.module_name == 'wxScreenDC'
           spec.make_abstract 'wxScreenDC'
+          spec.gc_never 'wxScreenDC'
           # as a ScreenDC should always be a temporary stack object
           # we do not allow creation in Ruby but rather provide a class
           # method for block execution on a temp dc
           spec.add_extend_code 'wxScreenDC', <<~__HEREDOC
             static VALUE paint(VALUE proc)
             {
+              VALUE rc = Qnil;
               if (rb_block_given_p ())
               {
                 wxScreenDC screen_dc;
                 wxDC* dc_ptr = &screen_dc;
                 VALUE rb_dc = SWIG_NewPointerObj(SWIG_as_voidptr(dc_ptr), SWIGTYPE_p_wxScreenDC, 0);
-                return rb_yield(rb_dc);
+                rc = rb_yield(rb_dc);
+                SWIG_RubyRemoveTracking((void *)dc_ptr);
+                DATA_PTR(rb_dc) = NULL;
               }
-              return Qnil;
+              return rc;
             }
             __HEREDOC
           # not relevant anymore
@@ -51,13 +55,100 @@ module WXRuby3
                       'wxSVGFileDC::StartPage',
                       'wxSVGFileDC::EndPage'
         elsif spec.module_name == 'wxGCDC'
+          spec.make_abstract 'wxGCDC'
+          spec.gc_never 'wxGCDC'
+          # as a GCDC should always be a temporary stack object
+          # we do not allow creation in Ruby but rather provide class
+          # methods for block execution on a temp dc
+          spec.add_extend_code 'wxGCDC', <<~__HEREDOC
+            static VALUE draw_on(const wxWindowDC& dc)
+            {
+              VALUE rc = Qnil;
+              if (rb_block_given_p ())
+              {
+                // Somehow there seems to be a problem with the Ruby GCDC value 
+                // being GC-ed unless we block GC for the duration of the block
+                // execution. Unclear why. We have similar code for other objects
+                // where this issue does not come up.
+                VALUE gc_on = rb_gc_disable();
+                wxGCDC gc_dc(dc);
+                wxGCDC* dc_ptr = &gc_dc;
+                VALUE rb_dc = SWIG_NewPointerObj(SWIG_as_voidptr(dc_ptr), SWIGTYPE_p_wxGCDC, 0);
+                rc = rb_yield(rb_dc);
+                SWIG_RubyRemoveTracking((void *)dc_ptr);
+                DATA_PTR(rb_dc) = NULL;
+                if (gc_on == Qtrue) rb_gc_enable();
+              }
+              return rc;
+            }
+            static VALUE draw_on(const wxMemoryDC& dc)
+            {
+              VALUE rc = Qnil;
+              if (rb_block_given_p ())
+              {
+                // Somehow there seems to be a problem with the Ruby GCDC value 
+                // being GC-ed unless we block GC for the duration of the block
+                // execution. Unclear why. We have similar code for other objects
+                // where this issue does not come up.
+                VALUE gc_on = rb_gc_disable();
+                wxGCDC gc_dc(dc);
+                wxGCDC* dc_ptr = &gc_dc;
+                VALUE rb_dc = SWIG_NewPointerObj(SWIG_as_voidptr(dc_ptr), SWIGTYPE_p_wxGCDC, 0);
+                rc = rb_yield(rb_dc);
+                SWIG_RubyRemoveTracking((void *)dc_ptr);
+                DATA_PTR(rb_dc) = NULL;
+                if (gc_on == Qtrue) rb_gc_enable();
+              }
+              return rc;
+            }
+            static VALUE draw_on(const wxPrinterDC& dc)
+            {
+              VALUE rc = Qnil;
+              if (rb_block_given_p ())
+              {
+                // Somehow there seems to be a problem with the Ruby GCDC value 
+                // being GC-ed unless we block GC for the duration of the block
+                // execution. Unclear why. We have similar code for other objects
+                // where this issue does not come up.
+                VALUE gc_on = rb_gc_disable();
+                wxGCDC gc_dc(dc);
+                wxGCDC* dc_ptr = &gc_dc;
+                VALUE rb_dc = SWIG_NewPointerObj(SWIG_as_voidptr(dc_ptr), SWIGTYPE_p_wxGCDC, 0);
+                rc = rb_yield(rb_dc);
+                SWIG_RubyRemoveTracking((void *)dc_ptr);
+                DATA_PTR(rb_dc) = NULL;
+                if (gc_on == Qtrue) rb_gc_enable();
+              }
+              return rc;
+            }
+            static VALUE draw_on(wxGraphicsContext* gc)
+            {
+              VALUE rc = Qnil;
+              if (rb_block_given_p ())
+              {
+                // Somehow there seems to be a problem with the Ruby GCDC value 
+                // being GC-ed unless we block GC for the duration of the block
+                // execution. Unclear why. We have similar code for other objects
+                // where this issue does not come up.
+                VALUE gc_on = rb_gc_disable();
+                wxGCDC gc_dc(gc);
+                wxGCDC* dc_ptr = &gc_dc;
+                VALUE rb_dc = SWIG_NewPointerObj(SWIG_as_voidptr(dc_ptr), SWIGTYPE_p_wxGCDC, 0);
+                rc = rb_yield(rb_dc);
+                SWIG_RubyRemoveTracking((void *)dc_ptr);
+                DATA_PTR(rb_dc) = NULL;
+                if (gc_on == Qtrue) rb_gc_enable();
+              }
+              return rc;
+            }
+          __HEREDOC
           spec.ignore 'wxGCDC::wxGCDC(const wxEnhMetaFileDC &)'
         elsif spec.module_name == 'wxScaledDC'
           spec.items.clear # wxRuby extension; no XML docs
           spec.override_inheritance_chain('wxScaledDC', %w[wxDC wxObject])
           # as there are no dependencies parsed from XML make sure we're initialized after Wx::DC
           spec.initialize_at_end = true
-          spec.gc_as_temporary 'wxScaledDC'
+          spec.gc_never 'wxScaledDC'
           spec.no_proxy 'wxScaledDC'
           spec.include 'wxruby-ScaledDC.h'
           # wxScaledDc should ever only be used in a restricted scope
@@ -67,16 +158,19 @@ module WXRuby3
           #  so we use a workaround here)
           spec.add_swig_code <<~__HEREDOC
             %extend wxScaledDC {
-            static void draw_on(wxDC& target, double scale)
+            static VALUE draw_on(wxDC& target, double scale)
             {
+              VALUE rc = Qnil;
               if (rb_block_given_p())
               {
                 wxScaledDC scaled_dc(target, scale);
                 wxScaledDC* p_scaled_dc = &scaled_dc;                        
                 VALUE rb_scaled_dc = SWIG_NewPointerObj(SWIG_as_voidptr(p_scaled_dc), SWIGTYPE_p_wxScaledDC, 0);
-                rb_yield(rb_scaled_dc);
+                rc = rb_yield(rb_scaled_dc);
+                SWIG_RubyRemoveTracking((void *)p_scaled_dc);
+                DATA_PTR(rb_scaled_dc) = NULL;
               }
-              return ;
+              return rc;
             }
             };
             __HEREDOC

data/rakelib/lib/director/dir_picker_ctrl.rb

@@ -13,6 +13,7 @@ module WXRuby3
 
       def setup
         super
+        spec.add_swig_code '%feature("notabstract") wxDirPickerCtrl;'
         spec.do_not_generate(:variables, :defines, :enums, :functions) # with FileDirPickerEvent
       end
     end # class DirPickerCtrl

data/rakelib/lib/director/event.rb

@@ -24,11 +24,68 @@ module WXRuby3
           # make Ruby director and wrappers use custom implementation
           spec.use_class_implementation('wxEvent', 'wxRubyEvent')
           spec.extend_interface('wxEvent', 'wxEvent(wxEventType commandType = wxEVT_NULL, int id = 0, int prop_level = wxEVENT_PROPAGATE_NONE)')
-          spec.extend_interface('wxEvent', 'virtual wxEvent* Clone() const')
-          spec.ignore %w[wxEvent::Clone wxEvent::GetEventUserData]
+          spec.ignore %w[wxEvent::GetEventUserData]
           spec.ignore 'wxEvent::wxEvent(int,wxEventType)'
           spec.no_proxy 'wxEvent::Clone'
+          spec.regard 'wxEvent::Clone', regard_doc: false # need updated doc
+          # need this to force alloc func
+          spec.add_swig_code '%feature("notabstract") wxEvent;'
+          # type mapping for result #clone
+          spec.map 'wxEvent*' => 'Wx::Event' do
+            map_out code: <<~__CODE
+              $result = wxRuby_WrapClonedWxEvent($1);
+              __CODE
+          end
           spec.add_header_code <<~__HEREDOC
+            static VALUE Evt_Type_Map = NULL;
+            static VALUE wxRuby_WrapClonedWxEvent(wxEvent* wx_evt)
+            {
+              wxString class_name( wx_evt->GetClassInfo()->GetClassName() );
+              if (class_name == "wxEvent" || class_name == "wxCommandEvent")
+              {
+                // special clones for Ruby derived events are already managed and tracked
+                return SWIG_RubyInstanceFor((void *)wx_evt);
+              }
+
+              // otherwise
+
+              // Get the mapping of event types to classes
+              if ( ! Evt_Type_Map )
+              {
+                Evt_Type_Map = wxRuby_GetEventTypeClassMap ();
+              }
+            
+              // Then, look up the event type in this hash (MUCH faster than calling
+              // EvtHandler.evt_class_for_type method)
+              VALUE rb_event_type_id =  INT2NUM( wx_evt->GetEventType() );
+              VALUE rb_event_class = rb_hash_aref(Evt_Type_Map, rb_event_type_id);
+
+              if ( NIL_P(rb_event_class) )
+              {
+                rb_event_class = wxRuby_GetDefaultEventClass();
+                rb_warning("Unmapped event type %i (%s)", wx_evt->GetEventType(), (const char *)class_name.mb_str());
+              }
+
+              // Wrap as owned object as this is a user code factory function.
+              swig_type_info*  type = wxRuby_GetSwigTypeForClass(rb_event_class);
+              swig_class* class_info = (swig_class*)type->clientdata;
+              // Create a new (owned) Ruby event object 
+              VALUE rb_evt = Data_Wrap_Struct(class_info->klass, VOIDFUNC(class_info->mark), 
+                                                                 VOIDFUNC(class_info->destroy), 
+                                                                 wx_evt);
+              // track new event object
+              SWIG_RubyAddTracking(wx_evt, rb_evt);
+              // do not forget to mark the instance with the mangled swig type name
+              rb_iv_set(rb_evt, "@__swigtype__", rb_str_new2(type->name));
+            
+            #if __WXRB_DEBUG__
+              if (wxRuby_TraceLevel()>1)
+                std::wcout << "* wxRuby_WrapClonedWxEvent - wrapped cloned event " << wx_evt << "{" << type->name << "}" << std::endl;
+            #endif
+            
+              return rb_evt;
+            }
+
             // Custom subclass implementation. Provide a constructor, destructor and
             // clone functions to allow proper linking to a Ruby object.
             class WXRUBY_EXPORT wxRubyEvent : public wxEvent
@@ -85,8 +142,8 @@ module WXRuby3
             wxCommandEvent::SetClientObject
             wxCommandEvent::GetExtraLong
           }
-          spec.extend_interface('wxCommandEvent', 'virtual wxCommandEvent* Clone() const')
-          spec.no_proxy 'wxCommandEvent::Clone'
+          # need this to force alloc func
+          spec.add_swig_code '%feature("notabstract") wxCommandEvent;'
           spec.add_header_code <<~__HEREDOC
             // Cf wxEvent - has to be written as a C+++ subclass to ensure correct
             // GC/thread protection of Ruby instance variables when user-written
@@ -129,7 +186,8 @@ module WXRuby3
             };
             __HEREDOC
           spec.add_wrapper_code <<~__HEREDOC
-            extern VALUE wxRuby_GetDefaultEventClass () {
+            extern VALUE wxRuby_GetDefaultEventClass() 
+            {
               return SwigClassWxEvent.klass;
             }
             __HEREDOC
@@ -145,8 +203,8 @@ module WXRuby3
 
       def process(gendoc: false)
         defmod = super
-        spec.items.each do |citem|
-          unless citem == 'wxEvent'
+        unless spec.module_name == 'wxEvent'
+          spec.items.each do |citem|
             def_item = defmod.find_item(citem)
             if Extractor::ClassDef === def_item
               if def_item.hierarchy.has_key?('wxEvent')
@@ -158,7 +216,14 @@ module WXRuby3
               elsif def_item.hierarchy.has_key?('wxNotifyEvent')
                 spec.override_inheritance_chain(citem, {'wxNotifyEvent' => 'wxEvents'}, {'wxCommandEvent' => 'wxEvent'}, 'wxEvent', 'wxObject')
               end
-              spec.make_abstract(citem) if citem == 'wxPaintEvent' # doc flaw
+              case citem
+              when 'wxNotifyEvent', 'wxPaintEvent'
+                # keep these abstract in wxRuby
+                spec.make_abstract(citem)
+              else
+                # need this to force alloc func
+                spec.add_swig_code "%feature(\"notabstract\") #{citem};"
+              end
             end
           end
         end

data/rakelib/lib/director/events.rb

@@ -24,7 +24,7 @@ module WXRuby3
           wxPaletteChangedEvent wxQueryNewPaletteEvent wxNavigationKeyEvent wxWindowCreateEvent
           wxWindowDestroyEvent wxHelpEvent wxClipboardTextEvent wxContextMenuEvent wxChildFocusEvent
           ])
-        spec.fold_bases('wxMouseEvent' => 'wxMouseState', 'wxKeyEvent' => 'wxKeyboardState')
+        spec.fold_bases('wxMouseEvent' => %w[wxMouseState wxKeyboardState], 'wxKeyEvent' => 'wxKeyboardState')
         spec.set_only_for 'WXWIN_COMPATIBILITY_2_8', 'wxShowEvent::GetShow', 'wxIconizeEvent::Iconized'
         spec.ignore 'wxKeyEvent::GetPosition(wxCoord *,wxCoord *) const'
         spec.ignore 'wxMouseState::GetPosition(int *,int *)'
@@ -32,6 +32,24 @@ module WXRuby3
         spec.do_not_generate(:variables, :defines, :enums, :functions)
       end
 
+      def process(gendoc: false)
+        defmod = super
+        # fix documentation errors for wxScrollEvent
+        def_item = defmod.find_item('wxScrollEvent')
+        if def_item
+          def_item.event_types.each do |evt_spec|
+            case evt_spec.first
+            when 'EVT_COMMAND_SCROLL_THUMBRELEASE', 'EVT_COMMAND_SCROLL_CHANGED'
+              if evt_spec[2] == 0
+                evt_spec[2] = 1       # incorrectly documented without 'id' argument
+                evt_spec[4] = true    # ignore extracted docs
+              end
+            end
+          end
+        end
+        defmod
+      end
+
     end # class Events
 
   end # class Director

data/rakelib/lib/director/file_picker_ctrl.rb

@@ -13,6 +13,7 @@ module WXRuby3
 
       def setup
         super
+        spec.add_swig_code '%feature("notabstract") wxFilePickerCtrl;'
         spec.do_not_generate(:variables, :defines, :enums, :functions) # with FileDirPickerEvent
       end
     end # class FilePickerCtrl

data/rakelib/lib/director/font_picker_ctrl.rb

@@ -13,6 +13,7 @@ module WXRuby3
 
       def setup
         super
+        spec.add_swig_code '%feature("notabstract") wxFontPickerCtrl;'
         spec.do_not_generate(:variables, :defines, :enums, :functions) # with FontPickerEvent
       end
     end # class FontPickerCtrl

data/rakelib/lib/director/gdicommon.rb

@@ -23,14 +23,12 @@ module WXRuby3
           'wxClientDisplayRect(int *,int *,int *,int *)',
           'wxDisplaySize(int *,int *)',
           'wxDisplaySizeMM(int *,int *)',
-          'wxRect::Inflate(wxCoord,wxCoord)',
           'wxRect::Inflate(wxCoord,wxCoord) const',
-          'wxRect::Deflate(wxCoord,wxCoord)',
           'wxRect::Deflate(wxCoord,wxCoord) const',
-          'wxRect::Offset(wxCoord,wxCoord)',
           'wxRect::Intersect(const wxRect &)',
           'wxRect::Union(const wxRect &)'
         ]
+        spec.regard 'wxRect::Offset', regard_doc: false
         # overrule common wxPoint mapping for wxRect ctor to fix ctor ambiguities here wrt wxSize
         spec.map 'const wxPoint& topLeft', 'const wxPoint& bottomRight', as: 'Wx::Point' do
           map_in code: <<~__CODE

data/rakelib/lib/director/graphics_context.rb

@@ -135,6 +135,95 @@ module WXRuby3
             }
             __CODE
         end
+        spec.new_object 'wxGraphicsContext::Create',
+                        'wxGraphicsContext::CreateFromUnknownDC'
+        # add convenience method providing efficient gc memory management
+        spec.add_extend_code 'wxGraphicsContext', <<~__HEREDOC
+          static VALUE draw_on(wxWindow* win)
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              wxGraphicsContext* p_gc = wxGraphicsContext::Create(win);
+              VALUE rb_gc = SWIG_NewPointerObj(SWIG_as_voidptr(p_gc), SWIGTYPE_p_wxGraphicsContext, 1);
+              rc = rb_yield(rb_gc);
+              SWIG_RubyRemoveTracking((void *)p_gc);
+              DATA_PTR(rb_gc) = NULL;
+              delete p_gc;
+            }
+            return rc;
+          }
+          static VALUE draw_on(const wxWindowDC& dc)
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              wxGraphicsContext* p_gc = wxGraphicsContext::Create(dc);
+              VALUE rb_gc = SWIG_NewPointerObj(SWIG_as_voidptr(p_gc), SWIGTYPE_p_wxGraphicsContext, 1);
+              rc = rb_yield(rb_gc);
+              SWIG_RubyRemoveTracking((void *)p_gc);
+              DATA_PTR(rb_gc) = NULL;
+              delete p_gc;
+            }
+            return rc;
+          }
+          static VALUE draw_on(const wxMemoryDC& dc)
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              wxGraphicsContext* p_gc = wxGraphicsContext::Create(dc);
+              VALUE rb_gc = SWIG_NewPointerObj(SWIG_as_voidptr(p_gc), SWIGTYPE_p_wxGraphicsContext, 1);
+              rc = rb_yield(rb_gc);
+              SWIG_RubyRemoveTracking((void *)p_gc);
+              DATA_PTR(rb_gc) = NULL;
+              delete p_gc;
+            }
+            return rc;
+          }
+          static VALUE draw_on(const wxPrinterDC& dc)
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              wxGraphicsContext* p_gc = wxGraphicsContext::Create(dc);
+              VALUE rb_gc = SWIG_NewPointerObj(SWIG_as_voidptr(p_gc), SWIGTYPE_p_wxGraphicsContext, 1);
+              rc = rb_yield(rb_gc);
+              SWIG_RubyRemoveTracking((void *)p_gc);
+              DATA_PTR(rb_gc) = NULL;
+              delete p_gc;
+            }
+            return rc;
+          }
+          static VALUE draw_on(wxImage& img)
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              wxGraphicsContext* p_gc = wxGraphicsContext::Create(img);
+              VALUE rb_gc = SWIG_NewPointerObj(SWIG_as_voidptr(p_gc), SWIGTYPE_p_wxGraphicsContext, 1);
+              rc = rb_yield(rb_gc);
+              SWIG_RubyRemoveTracking((void *)p_gc);
+              DATA_PTR(rb_gc) = NULL;
+              delete p_gc;
+            }
+            return rc;
+          }
+          static VALUE draw_on()
+          {
+            VALUE rc = Qnil;
+            if (rb_block_given_p())
+            {
+              wxGraphicsContext* p_gc = wxGraphicsContext::Create();
+              VALUE rb_gc = SWIG_NewPointerObj(SWIG_as_voidptr(p_gc), SWIGTYPE_p_wxGraphicsContext, 1);
+              rc = rb_yield(rb_gc);
+              SWIG_RubyRemoveTracking((void *)p_gc);
+              DATA_PTR(rb_gc) = NULL;
+              delete p_gc;
+            }
+            return rc;
+          }
+          __HEREDOC
       end
     end # class GraphicsContext
 

data/rakelib/lib/director/help_controller.rb

@@ -43,8 +43,8 @@ module WXRuby3
             {
               rc = rb_ary_new();
               rb_ary_push(rc, wxRuby_WrapWxObjectInRuby(result));
-              rb_ary_push(rc, SWIG_NewPointerObj(SWIG_as_voidptr(&size), SWIGTYPE_p_wxSize, 0));
-              rb_ary_push(rc, SWIG_NewPointerObj(SWIG_as_voidptr(&pos), SWIGTYPE_p_wxPoint, 0));
+              rb_ary_push(rc, SWIG_NewPointerObj(new wxSize(size), SWIGTYPE_p_wxSize, 1));
+              rb_ary_push(rc, SWIG_NewPointerObj(new wxPoint(pos), SWIGTYPE_p_wxPoint, 1));
               rb_ary_push(rc, newFrameEachTime ? Qtrue : Qfalse);
             }
             return rc;

data/rakelib/lib/director/html_data_object.rb

@@ -0,0 +1,37 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class HTMLDataObject < Director
+
+      include Typemap::DataFormat
+      include Typemap::DataObjectData
+
+      def setup
+        super
+        spec.gc_as_object
+        # make sure the build scripts know that DataObjectSimple is part of the DataObject module
+        spec.override_inheritance_chain('wxHTMLDataObject', {'wxDataObjectSimple' => 'wxDataObject'}, 'wxDataObject')
+        # we only allow Ruby derivatives from wxDataObject but not of any of the C++ implemented
+        # specializations
+        spec.no_proxy 'wxHTMLDataObject'
+        spec.add_swig_code <<~__HEREDOC
+            // SWIG gets confused and doesn't realise that various virtual methods
+            // from wxDataObject are implemented fully in this subclass, and so,
+            // believing it to be abstract doesn't provide an allocator for this
+            // class. This undocumented feature overrides this.
+            %feature("notabstract") wxHTMLDataObject;
+        __HEREDOC
+
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/director/image.rb

@@ -43,6 +43,61 @@ module WXRuby3
           wxImage::InsertHandler
           wxImage::RemoveHandler
           ]
+        # add convenience class methods
+        spec.add_extend_code 'wxImage', <<~__HEREDOC
+          static VALUE handlers()
+          {
+            VALUE hnd_ary = rb_ary_new();
+            wxList& hnd_lst = wxImage::GetHandlers();
+            for (wxList::compatibility_iterator node = hnd_lst.GetFirst();
+                    node; node = node->GetNext())
+            {
+              wxImageHandler *handler = (wxImageHandler *) node->GetData();
+              wxBitmapType bmp_type = handler->GetType();
+              rb_ary_push(hnd_ary, wxRuby_GetEnumValueObject("wxBitmapType", (int)bmp_type));
+            }
+            return hnd_ary;
+          }
+
+          static VALUE extensions()
+          {
+            VALUE ext_ary = rb_ary_new();
+            wxList& hnd_lst = wxImage::GetHandlers();
+            for (wxList::compatibility_iterator node = hnd_lst.GetFirst();
+                    node; node = node->GetNext())
+            {
+              wxImageHandler *handler = (wxImageHandler *) node->GetData();
+              rb_ary_push(ext_ary, WXSTR_TO_RSTR(handler->GetExtension()));
+              const wxArrayString& alt_ext = handler->GetAltExtensions();
+              for (wxArrayString::const_iterator it = alt_ext.begin(); it!=alt_ext.end() ;++it)
+              {
+                rb_ary_push(ext_ary, WXSTR_TO_RSTR((*it)));
+              }
+            }
+            return ext_ary;
+          }
+
+          static VALUE handler_extensions()
+          {
+            VALUE ext_hash = rb_hash_new();
+            wxList& hnd_lst = wxImage::GetHandlers();
+            for (wxList::compatibility_iterator node = hnd_lst.GetFirst();
+                    node; node = node->GetNext())
+            {
+              wxImageHandler *handler = (wxImageHandler *) node->GetData();
+              VALUE ext_ary = rb_ary_new();
+              rb_ary_push(ext_ary, WXSTR_TO_RSTR(handler->GetExtension()));
+              const wxArrayString& alt_ext = handler->GetAltExtensions();
+              for (wxArrayString::const_iterator it = alt_ext.begin(); it!=alt_ext.end() ;++it)
+              {
+                rb_ary_push(ext_ary, WXSTR_TO_RSTR((*it)));
+              }
+              wxBitmapType bmp_type = handler->GetType();
+              rb_hash_aset(ext_hash, wxRuby_GetEnumValueObject("wxBitmapType", (int)bmp_type), ext_ary);
+            }
+            return ext_hash;
+          }
+          __HEREDOC
         # The GetRgbData and GetAlphaData methods require special handling using %extend;
         spec.ignore %w[wxImage::GetData wxImage::GetAlpha]
         # The SetRgbData and SetAlphaData are dealt with by typemaps (see below).