wxruby3 0.9.0.pre.beta.10 → 0.9.0.pre.beta.13

data/rakelib/lib/director/clipboard.rb

@@ -13,7 +13,7 @@ module WXRuby3
 
       def setup
         super
-        spec.gc_never
+        spec.gc_as_temporary # don't even track Clipboard objects
         # there is no need or support for clipboard derivatives
         # not least because wxRuby only ever allows a single global clipboard
         spec.disable_proxies

data/rakelib/lib/director/colour_picker_ctrl.rb

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

data/rakelib/lib/director/data_object.rb

@@ -56,9 +56,171 @@ module WXRuby3
         # Once a DataObject has been added, it belongs to the wxDataObjectComposite object,
         # and will be freed by it on destruction.
         spec.disown 'wxDataObjectSimple* dataObject'
+
+        # Add GC management for the DataObjectSimple instances added to a DataObjectComposite instance.
+        spec.add_header_code <<~__HEREDOC
+          #include <vector>
+          #include <map>
+
+          typedef std::vector<VALUE> data_object_list_t;
+          typedef std::map<wxDataObjectComposite*, data_object_list_t> composite_data_object_map_t;
+          static composite_data_object_map_t CompositeDataObject_Map;
+
+          static void GC_mark_wxCompositeDataObject(void* ptr)
+          {
+            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)
+              {
+          #ifdef __WXRB_DEBUG__
+                if (wxRuby_TraceLevel()>1)
+                {
+                  void *c_ptr = (TYPE(data_obj) == T_DATA ? DATA_PTR(data_obj) : 0);
+                  std::wcout << "**** wxRuby_markCompositeDataObjects : " << it->first << "|" << (void*)c_ptr << std::endl;
+                }
+          #endif               
+                rb_gc_mark(data_obj);
+              }
+            }
+          }
+
+          // custom implementation for wxRuby so we can handle de-registering composites
+          class WxRuby_DataObjectComposite : public wxDataObjectComposite
+          {
+          public:
+            WxRuby_DataObjectComposite() : wxDataObjectComposite() {}
+            virtual ~WxRuby_DataObjectComposite()
+            {
+              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_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
+        spec.add_extend_code 'wxDataObjectComposite', <<~__HEREDOC
+          void add(VALUE rb_dataObject, bool preferred=false)
+          {
+            // convert simple object
+            wxDataObjectSimple *simple_do;
+            int res = SWIG_ConvertPtr(rb_dataObject, SWIG_as_voidptrptr(&simple_do), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN);
+            if (!SWIG_IsOK(res)) 
+            {
+              rb_raise(rb_eArgError, "Expected Wx::DataObjectSimple for 1");
+            }
+
+            // add new simple instance to registration for this composite
+            CompositeDataObject_Map[$self].push_back(rb_dataObject);
+
+            // add to composite
+            $self->Add(simple_do);
+          }
+          __HEREDOC
+
       end
     end # class DataObject
 
+    def doc_generator
+      DataObjectDocGenerator.new(self)
+    end
+
   end # class Director
 
+  class DataObjectDocGenerator < DocGenerator
+
+    def get_class_doc(clsdef)
+      if clsdef.name == 'wxDataObjectSimple'
+        []
+      else
+        super
+      end
+    end
+    protected :get_class_doc
+
+    def get_method_doc(mtd)
+      if Extractor::MethodDef === mtd && mtd.class_name == 'wxDataObject' && mtd.name == 'GetDataSize'
+        {}
+      else
+        super
+      end
+    end
+    protected :get_method_doc
+
+  end
+
 end # module WXRuby3

data/rakelib/lib/director/data_object_simple_base.rb

@@ -0,0 +1,123 @@
+###
+# wxRuby3 wxWidgets interface director
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  class Director
+
+    class DataObjectSimpleBase < Director
+
+      include Typemap::DataFormat
+      include Typemap::DataObjectData
+
+      def setup
+        super
+        spec.items.clear
+        # insert literal code as #gc_as_xx does not work without parsed class items
+        spec.add_swig_code 'GC_MANAGE_AS_OBJECT(wxDataObjectSimpleBase);'
+        spec.initialize_at_end = true
+
+        spec.swig_import 'ext/wxruby3/swig/classes/include/wxDataObject.h'
+
+        spec.add_header_code <<~__HEREDOC
+          class wxDataObjectSimpleBase : public wxDataObjectSimple
+          {
+          public:
+            wxDataObjectSimpleBase(const wxDataFormat &format=wxFormatInvalid)
+              : wxDataObjectSimple(format) {}
+            virtual ~wxDataObjectSimpleBase() { }
+          
+            virtual size_t GetDataSize() const { return _GetDataSize(); }
+            virtual size_t GetDataSize(const wxDataFormat &) const { return _GetDataSize(); }
+            virtual bool GetDataHere(const wxDataFormat &, void *buf) const { return _GetData(buf); }
+            virtual bool GetDataHere(void *data_buffer) const { return _GetData(data_buffer); }
+            virtual bool SetData(const wxDataFormat &, size_t len, const void *buf) { return _SetData(len, buf); }
+            virtual bool SetData(size_t len, const void *buf) { return _SetData(len, buf); }
+          
+          protected:
+            virtual size_t _GetDataSize() const { return 0; }
+            virtual bool _GetData(void *data_buffer) const { return false; }
+            virtual bool _SetData(size_t len, const void *buf) { return false; }
+          };
+          __HEREDOC
+
+        spec.add_interface_code <<~__HEREDOC
+          class wxDataObjectSimpleBase : public wxDataObjectSimple
+          {
+          public:
+            wxDataObjectSimpleBase(const wxDataFormat &format=wxFormatInvalid);
+          
+            virtual void GetAllFormats(wxDataFormat *formats, Direction dir=Get) const;
+            virtual size_t GetFormatCount(Direction dir=Get) const;
+            virtual wxDataFormat GetPreferredFormat(Direction dir=Get) const;
+          
+          protected:
+            virtual size_t _GetDataSize() const;
+            %feature("numoutputs", "0") _GetData;
+            virtual VOID_BOOL _GetData(void *data_buffer) const;
+            virtual bool _SetData(size_t len, const void *buf);
+          };
+          __HEREDOC
+
+        # For wxDataObjectSimpleBase::GetDataHere/_GetData : the ruby method should
+        # return either a string containing the
+        # data, or nil if the data cannot be provided for some reason.
+        spec.map 'void *data_buffer' do
+
+          map_in ignore: true, code: ''
+
+          # "misuse" the 'check' typemap to initialize the ignored argument
+          # since this is inserted after any non-ignored arguments have been converted we can use these
+          # here
+          map_check temp: 'std::unique_ptr<char[]> data_buf, size_t data_size', code: <<~__CODE
+            data_size = arg1->GetDataSize();
+            data_buf = std::make_unique<char[]>(data_size);
+            $1 = data_buf.get ();
+          __CODE
+
+          # ignore C defined return value entirely (also affects directorout)
+          map_out ignore: 'bool'
+
+          map_argout as: {type: 'String', index: 1}, code: <<~__CODE
+            if (result)
+            {
+              $result = rb_utf8_str_new( (const char*)data_buf$argnum.get(), data_size$argnum);
+            }
+            else
+              $result = Qnil;
+          __CODE
+
+          # ignore the buffer pointer for now
+          map_directorin code: ''
+
+          map_directorargout code: <<~__CODE
+            if (RTEST(result))
+            {
+              if (TYPE(result) == T_STRING)
+              {
+                memcpy(data_buffer, StringValuePtr(result), RSTRING_LEN(result) );
+                c_result = true;
+              }
+              else
+              {
+                Swig::DirectorTypeMismatchException::raise(rb_eTypeError, 
+                                                           "get_data_here should return a string, or nil on failure");
+              }
+            }
+            else
+              c_result = false;
+          __CODE
+
+        end
+
+        # Once a DataObject has been added, it belongs to the wxDataObjectComposite object,
+        # and will be freed by it on destruction.
+        # spec.disown 'wxDataObjectSimple* dataObject'
+      end
+    end # class DataObject
+
+  end # class Director
+
+end # module WXRuby3

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,7 +55,135 @@ 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_never 'wxScaledDC'
+          spec.no_proxy 'wxScaledDC'
+          spec.include 'wxruby-ScaledDC.h'
+          # wxScaledDc should ever only be used in a restricted scope
+          # to be destructed directly after use therefor we make it abstract
+          # and provide a class factory method #draw_on with accepts a block.
+          # (as we there no classes defined in XML we cannot use add_extend_code
+          #  so we use a workaround here)
+          spec.add_swig_code <<~__HEREDOC
+            %extend wxScaledDC {
+            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);
+                rc = rb_yield(rb_scaled_dc);
+                SWIG_RubyRemoveTracking((void *)p_scaled_dc);
+                DATA_PTR(rb_scaled_dc) = NULL;
+              }
+              return rc;
+            }
+            };
+            __HEREDOC
+          spec.swig_import %w[ext/wxruby3/swig/classes/include/wxObject.h
+                              ext/wxruby3/swig/classes/include/wxDC.h]
+          spec.add_interface_code <<~__HEREDOC
+            class wxScaledDC : public wxDC
+            {
+            public:
+              wxScaledDC(wxDC& target, double scale);
+              virtual ~wxScaledDC() = 0;
+            };
+            __HEREDOC
         else
           # ctors of all other derived DC require a running App
           spec.require_app spec.module_name

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