wxruby3 0.9.2 → 0.9.4

data/rakelib/lib/director/sizer.rb

@@ -12,12 +12,19 @@ module WXRuby3
 
     class Sizer < Director
 
+      include Typemap::ClientData
+
       def setup
-        # Any nested sizers passed to Add() in are owned by C++, not GC'd by Ruby
+        # Any nested sizers passed to Add() in are owned by C++, not GC-ed by Ruby
         case spec.module_name
         when 'wxSizer'
           spec.items << 'wxSizerFlags'
           spec.gc_as_untracked('wxSizerFlags')
+          if Config.instance.wx_version < '3.3.0'
+            # missing from docs
+            spec.extend_interface 'wxSizerFlags',
+                                  'wxSizerFlags& HorzBorder()'
+          end
           spec.make_abstract('wxSizer')
           spec.ignore %w[wxSizer::IsShown wxSizer::SetVirtualSizeHints]
           # cannot use these with wxRuby
@@ -45,7 +52,7 @@ module WXRuby3
           spec.ignore 'wxSizer::Detach(wxSizer*)',
                       'wxSizer::Detach(int)', ignore_doc: false
           spec.add_extend_code 'wxSizer', <<~__HEREDOC
-            bool detach(wxSizer* szr)
+            bool Detach(wxSizer* szr)
             {
               if ($self->Detach(szr))
               {
@@ -60,7 +67,7 @@ module WXRuby3
               return false;
             }
 
-            bool detach(int itm_nr)
+            bool Detach(int itm_nr)
             {
               wxSizerItem* itm = $self->GetItem(itm_nr);
               if (itm)
@@ -124,9 +131,13 @@ module WXRuby3
           spec.ignore 'wxGridBagSizer::Add(wxGBSizerItem *)'
           # need to adjust sizer arg name to apply disown specs
           spec.ignore 'wxGridBagSizer::Add(wxSizer *, const wxGBPosition &, const wxGBSpan &, int, int, wxObject *)',
+                      'wxGridBagSizer::Add(wxWindow *, const wxGBPosition &, const wxGBSpan &, int, int, wxObject *)',
+                      'wxGridBagSizer::Add(int, int, const wxGBPosition &, const wxGBSpan &, int, int, wxObject *)',
                       ignore_doc: false
           spec.extend_interface 'wxGridBagSizer',
-                                'wxSizerItem *Add(wxSizer *sizer_disown, const wxGBPosition &pos, const wxGBSpan &span=wxDefaultSpan, int flag=0, int border=0, wxObject *userData=NULL)'
+                                'wxSizerItem * Add(wxSizer *sizer_disown, const wxGBPosition &pos, const wxGBSpan &span=wxDefaultSpan, int flag=0, int border=0, wxObject *userData=NULL)',
+                                'wxSizerItem * Add(wxWindow *window, const wxGBPosition &pos, const wxGBSpan &span=wxDefaultSpan, int flag=0, int border=0, wxObject *userData=NULL)',
+                                'wxSizerItem * Add(int width, int height, const wxGBPosition &pos, const wxGBSpan &span=wxDefaultSpan, int flag=0, int border=0, wxObject *userData=NULL)'
           spec.disown 'wxSizer* sizer_disown'
         end
         # no real use for allowing these to be overloaded but a whole lot of grieve

data/rakelib/lib/director/sizer_item.rb

@@ -12,15 +12,27 @@ module WXRuby3
 
     class SizerItem < Director
 
+      include Typemap::ClientData
+
       def setup
         spec.disable_proxies
         # do not allow creating SizerItems in Ruby; this has limited benefits and
         # memory management of sizer items is a nightmare
         case spec.module_name
         when 'wxSizerItem'
+          spec.gc_as_untracked 'wxSizerItem'
           spec.make_abstract 'wxSizerItem'
           # ignore constructors
           spec.ignore 'wxSizerItem::wxSizerItem'
+          # needs more discriminating return type for type map
+          spec.ignore 'wxSizerItem::GetUserData', ignore_doc: false
+          spec.add_header_code 'typedef wxObject* WxUserDataObject;'
+          spec.extend_interface 'wxSizerItem',
+                                'WxUserDataObject GetUserData() const'
+          # for doc gen only
+          spec.map 'wxObject*' => 'Object', swig: false do
+            map_out code: ''
+          end
           spec.ignore(%w[wxSizerItem::SetSizer wxSizerItem::SetSpacer wxSizerItem::SetWindow])
           # need to adjust sizer arg name to apply disown specs
           spec.ignore 'wxSizerItem::AssignSizer(wxSizer *)', ignore_doc: false
@@ -45,6 +57,7 @@ module WXRuby3
             }
             __HEREDOC
         when 'wxGBSizerItem'
+          spec.gc_as_untracked 'wxGBSizerItem'
           spec.make_abstract 'wxGBSizerItem'
           # ignore constructors
           spec.ignore 'wxGBSizerItem::wxGBSizerItem',

data/rakelib/lib/director/static_bitmap.rb

@@ -20,6 +20,38 @@ module WXRuby3
           __HEREDOC
         super
       end
+
+      def process(gendoc: false)
+        defmod = super
+        spec.include 'wx/generic/statbmpg.h'
+        def_statbmp = defmod.find_item('wxStaticBitmap')
+        # create a definition for 'wxGenericStaticBitmap' which is not documented
+        def_genstatbmp = def_statbmp.dup
+        def_genstatbmp.name = 'wxGenericStaticBitmap'
+        def_genstatbmp.brief_doc = nil
+        def_genstatbmp.detailed_doc = nil
+        def_genstatbmp.items = def_genstatbmp.items.collect { |itm| itm.dup }
+        def_genstatbmp.items.each do |itm|
+          if itm.is_a?(Extractor::MethodDef)
+            itm.overloads = itm.overloads.collect { |ovl| ovl.dup }
+            itm.all.each do |ovl|
+              ovl.name = 'wxGenericStaticBitmap' if ovl.is_ctor
+              ovl.class_name = 'wxGenericStaticBitmap'
+              ovl.update_attributes(klass: def_genstatbmp)
+            end
+          end
+        end
+        def_genstatbmp.items.delete_if { |itm| itm.is_a?(Extractor::EnumDef) && itm.name == 'ScaleMode' }
+        spec.add_swig_code %Q{typedef wxStaticBitmap::ScaleMode ScaleMode; }
+        spec.add_header_code %Q{typedef wxStaticBitmap::ScaleMode ScaleMode; }
+        defmod.items << def_genstatbmp
+        # as we already called super before adding wxGenericStaticBitmap the no_proxy settings from the
+        # base Window director are missing; just copy all those set for wxStaticBitmap
+        list = spec.no_proxies.select { |name| name.start_with?('wxStaticBitmap::') }
+        spec.no_proxy(*list.collect { |name| name.sub(/\AwxStaticBitmap::/, 'wxGenericStaticBitmap::')})
+        defmod
+      end
+
     end # class StaticBitmap
 
   end # class Director

data/rakelib/lib/director/text_entry.rb

@@ -15,7 +15,7 @@ module WXRuby3
       def setup
         super
         spec.items << 'wxTextCompleter' << 'wxTextCompleterSimple'
-        spec.gc_as_untracked 'wxTextCompleter', 'wxTextCompleterSimple'
+        spec.gc_as_marked 'wxTextCompleter', 'wxTextCompleterSimple' # untracked but cached in Ruby
         spec.gc_as_untracked 'wxTextEntry' # actually no GC control necessary as this is a mixin only
         # turn wxTextEntry into a mixin module
         spec.make_mixin 'wxTextEntry'
@@ -26,6 +26,10 @@ module WXRuby3
         spec.add_header_code '#define wxTextEntry wxTextEntryBase'
         spec.disown 'wxTextCompleter *completer' # managed by wxWidgets after passing in
         spec.map_apply 'long * OUTPUT' => 'long *' # for GetSelection
+        # missing non-pure virtual overrides in docs for wxTextCompleterSimple
+        spec.extend_interface 'wxTextCompleterSimple',
+                              'virtual bool Start(const wxString &prefix)',
+                              'virtual wxString GetNext()'
         # for wxTextCompleterSimple::GetCompletions
         spec.map 'wxArrayString &res' => 'Array<String>' do
 

data/rakelib/lib/director/text_validator.rb

@@ -6,48 +6,159 @@
 # wxRuby3 wxWidgets interface director
 ###
 
-require_relative './event_handler'
+require_relative './validator'
 
 module WXRuby3
 
   class Director
 
-    class TextValidator < EvtHandler
+    class TextValidator < Validator
 
       def setup
         super
         # need a custom implementation to handle event handler proc cleanup
         spec.add_header_code <<~__HEREDOC
-          class WXRubyTextValidator : public wxTextValidator
+          class WXRubyTextValidator : public wxTextValidator, public wxRubyValidatorBinding
           {
           public:
-            WXRubyTextValidator(const wxTextValidator& v) 
-              : wxTextValidator(v) {}
             WXRubyTextValidator(long style=wxFILTER_NONE) 
-              : wxTextValidator(style) {}
+              : wxTextValidator(style, &m_valueCache) 
+            {
+            }
+            WXRubyTextValidator(const WXRubyTextValidator& other) 
+              : wxTextValidator(other.GetStyle(), &m_valueCache)
+              , wxRubyValidatorBinding(other)
+            {
+            }
             virtual ~WXRubyTextValidator() 
             {
               wxRuby_ReleaseEvtHandlerProcs(this);
-            }               
+            }
+
+            virtual wxObject* Clone() const override
+            {
+              WXRubyTextValidator* clone = new WXRubyTextValidator(*this);
+              clone->m_valueCache = this->m_valueCache;
+              return clone;
+            }
+
+            virtual void SetWindow(wxWindow *win) override
+            {
+              this->wxTextValidator::SetWindow(win);
+              VALUE self = this->get_self();
+              // make sure Ruby does not own this validator instance anymore
+              RDATA(self)->dfree = SWIG_RubyRemoveTracking;
+            } 
+
+            virtual bool TransferFromWindow () override 
+            {
+              // call super 
+              if (this->wxTextValidator::TransferFromWindow())
+              {
+                // ok, data is retrieved from window and cached
+                // now allow any defined binding handler to pass on the data
+                return this->DoOnTransferFromWindow(WXSTR_TO_RSTR(m_valueCache));
+              } 
+              return false;
+            }
+            virtual bool TransferToWindow () override 
+            { 
+              // collect data from any defined binding handler
+              VALUE data = this->DoOnTransferToWindow();
+              // if Qnil returned there is no data returned from handler so we just keep what's in the store
+              if (!NIL_P(data))
+              {
+                m_valueCache = RSTR_TO_WXSTR(data);
+              }
+              // now allow standard functionality to transfer to window 
+              return this->wxTextValidator::TransferToWindow();
+            }
+
+            const wxString& GetValue () const
+            {
+              return m_valueCache;
+            }
+
+            void SetValue (const wxString& val)
+            {
+              m_valueCache = val;
+            }
+
+          private:
+            static VALUE c_TextValidator; 
+
+            virtual VALUE get_self() override
+            {
+              if (NIL_P(this->self_))
+              {
+                this->self_ = SWIG_RubyInstanceFor(this);
+                // if this is a C++ created clone (wxWidgets clones validators that are set) it's not tracked yet
+                if (NIL_P(this->self_))
+                {
+                  if (NIL_P(c_TextValidator))
+                  {
+                    c_TextValidator = rb_const_get(mWxCore, rb_intern("TextValidator"));
+                  }
+                  swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(c_TextValidator);
+                  this->self_ = SWIG_NewPointerObj(this, swig_type, 0); // wrap but don't make Ruby own it
+                }
+              }
+              return this->self_; 
+            }
+
+            wxString m_valueCache;               
           };
-        __HEREDOC
+
+          VALUE WXRubyTextValidator::c_TextValidator = Qnil;
+
+          static void GC_mark_wxTextValidator(void* ptr)
+          {
+            if (ptr)
+            {
+              wxValidator* vp = reinterpret_cast<wxValidator*> (ptr);
+              WXRubyTextValidator* rbvp = dynamic_cast<WXRubyTextValidator*> (vp);
+              // This might be a pointer to a non-customized validator (or clone thereof) created internally 
+              // by wxWidgets C++ code 
+              if (rbvp) rbvp->GC_Mark();
+            }
+          } 
+
+          __HEREDOC
+        spec.add_swig_code '%markfunc wxTextValidator "GC_mark_wxTextValidator";'
+        # make Ruby director and wrappers use custom implementation
         spec.use_class_implementation 'wxTextValidator', 'WXRubyTextValidator'
-        # ignore copy ctor doc
-        spec.regard 'wxTextValidator::wxTextValidator(const wxTextValidator&)', regard_doc: false
         # ignore this ctor
         spec.ignore 'wxTextValidator::wxTextValidator(long, wxString*)'
         # add alternative
         spec.extend_interface 'wxTextValidator', 'wxTextValidator(long style=wxFILTER_NONE)'
-        # ignore non-virtual standard handler (not really useful in Ruby)
+        # add wxRuby extensions
+        spec.add_extend_code 'wxTextValidator', <<~__HEREDOC
+          VALUE GetValue()
+          {
+            WXRubyTextValidator* rb_self = dynamic_cast<WXRubyTextValidator*> ($self);
+            if (rb_self)
+              return WXSTR_TO_RSTR(rb_self->GetValue());
+            else
+              return Qnil;
+          }
+
+          void SetValue(const wxString& val)
+          {
+            WXRubyTextValidator* rb_self = dynamic_cast<WXRubyTextValidator*> ($self);
+            if (rb_self)
+              rb_self->SetValue(val);
+          }
+          __HEREDOC
+        # ignore non-virtual standard handler (not useful in Ruby)
         spec.ignore 'wxTextValidator::OnChar'
-        spec.no_proxy 'wxTextValidator::Clone'
         spec.new_object 'wxTextValidator::Clone'
         # handle clone mapping
         spec.map 'wxObject *' => 'Wx::TextValidator' do
           map_out code: <<~__CODE
-            $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), SWIGTYPE_p_wxTextValidator, SWIG_POINTER_OWN |  0 );
+            $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), SWIGTYPE_p_wxTextValidator, SWIG_POINTER_OWN);
             __CODE
         end
+        spec.suppress_warning(473, 'wxTextValidator::Clone')
         # not provided in Ruby
         spec.ignore %w[wxTextValidator::TransferFromWindow wxTextValidator::TransferToWindow]
       end

data/rakelib/lib/director/toggle_button.rb

@@ -15,6 +15,7 @@ module WXRuby3
     class ToggleButton < Window
 
       def setup
+        spec.items << 'wxBitmapToggleButton'
         spec.include('wx/tglbtn.h')
         super
       end

data/rakelib/lib/director/top_level_window.rb

@@ -26,10 +26,8 @@ module WXRuby3
           # for upcalls
           spec.extend_interface('wxTopLevelWindow',
                                 'virtual bool Destroy() override',
-                                #'virtual bool IsTopLevel() override',
                                 'virtual void SetLayoutDirection(wxLayoutDirection dir) override',
                                 'virtual bool Show(bool show = true) override',
-                                'virtual void Raise() override',
                                 'virtual void Refresh(bool eraseBackground = true, wxRect const *rect = NULL) override')
           spec.add_wrapper_code <<~__HEREDOC
             extern VALUE wxRuby_GetTopLevelWindowClass() {

data/rakelib/lib/director/tree_ctrl.rb

@@ -50,6 +50,41 @@ module WXRuby3
           wxTreeCtrl::GetFirstChild
           wxTreeCtrl::GetNextChild
           ]
+        if Config.instance.wx_version >= '3.3.0'
+          # new method with bitmap bundle vector
+          spec.no_proxy 'wxTreeCtrl::SetStateImages'
+          spec.map 'const wxVector<wxBitmapBundle>& images' => 'Array<Wx::ImageBundle>' do
+            map_in temp: 'wxVector<wxBitmapBundle> tmp', code: <<~__CODE
+            if ($input != Qnil)
+            {
+              if (TYPE($input) == T_ARRAY)
+              {
+                for (int i=0; i<RARRAY_LEN($input) ;++i)
+                {
+                  void* ptr;
+                  VALUE rb_image = rb_ary_entry($input, i);
+                  int res = SWIG_ConvertPtr(rb_image, &ptr, wxRuby_GetSwigTypeForClassName("BitmapBundle"), 0);
+                  if (!SWIG_IsOK(res)) 
+                  {
+                    VALUE msg = rb_inspect(rb_image);
+                    rb_raise(rb_eTypeError, "Expected Wx::ImageBundle at index %d but got %s", i, StringValuePtr(msg));
+                  }
+                  tmp.push_back(*static_cast<wxBitmapBundle*>(ptr));
+                }
+              }
+              else
+              {
+                VALUE msg = rb_inspect($input);
+                rb_raise(rb_eArgError, "Expected Array of Wx::ImageBundle for $argnum but got %s", StringValuePtr(msg));
+              }
+            }
+            $1 = &tmp;
+            __CODE
+          end
+        end
+        # don't see how supporting overloading this one in Ruby is helpful
+        # (also seeing SetButtonsImageList isn't virtual at all)
+        spec.no_proxy 'wxTreeCtrl::SetStateImageList'
         # these are potentially involved in GC mark phase so
         # we can't have them redirecting to Ruby calls
         spec.no_proxy %w[

data/rakelib/lib/director/utils.rb

@@ -41,8 +41,22 @@ module WXRuby3
           wxNow
           wxDecToHex
           wxHexToDec
-          wxStripMenuCodes
           ]
+        # ignore these enum(erator)s
+        spec.ignore %w[
+          wxSignal
+          wxKillError
+          wxKillFlags
+          wxShutdownFlags
+          @.wxEXEC_ASYNC
+          @.wxEXEC_SYNC
+          @.wxEXEC_SHOW_CONSOLE
+          @.wxEXEC_MAKE_GROUP_LEADER
+          @.wxEXEC_NODISABLE
+          @.wxEXEC_NOEVENTS
+          @.wxEXEC_HIDE_CONSOLE
+          @.wxEXEC_BLOCK
+        ]
         spec.ignore 'wxPostDelete'  unless Config.instance.wx_version >= '3.3.0'
         spec.ignore 'wxGetEmailAddress(char *,int)',
                     'wxGetUserId(char *,int)',
@@ -53,7 +67,7 @@ module WXRuby3
             __CODE
         end
         # we want only the functions that are not ignored
-        spec.do_not_generate(:classes, :typedefs, :variables, :enums, :defines)
+        spec.do_not_generate(:classes, :typedefs, :variables, :defines)
         super
       end
     end # class Utils

data/rakelib/lib/director/validator.rb

@@ -16,29 +16,204 @@ module WXRuby3
 
       def setup
         super
-        # make Ruby director and wrappers use custom implementation
-        spec.use_class_implementation('wxValidator', 'wxRubyValidator')
-        # provide custom wxRuby derivative of validator
-        spec.add_header_code <<~__HEREDOC
-          class wxRubyValidator : public wxValidator
-          {
-          public:
-            wxRubyValidator () : wxValidator () {}
-            virtual ~wxRubyValidator ()
+        if spec.module_name == 'wxValidator'
+          # make Ruby director and wrappers use custom implementation
+          spec.use_class_implementation('wxValidator', 'wxRubyValidator')
+          # provide custom wxRuby derivative of validator
+          spec.add_header_code <<~__HEREDOC
+            #include "wxruby-Validator.h"
+  
+            WxRuby_ID wxRubyValidator::do_transfer_from_window_id("do_transfer_from_window");
+            WxRuby_ID wxRubyValidator::do_transfer_to_window_id("do_transfer_to_window");
+            WxRuby_ID wxRubyValidator::clone_id("clone");
+
+            wxRubyValidator::wxRubyValidator () 
+              : wxValidator ()
+              , wxRubyValidatorBinding () 
+            {}
+            wxRubyValidator::wxRubyValidator (const wxRubyValidator& v)
+              : wxValidator (v)
+              , wxRubyValidatorBinding (v)
+            {}
+            wxRubyValidator::~wxRubyValidator ()
             {
               wxRuby_ReleaseEvtHandlerProcs(this);
-            }               
-
-            // these two methods are noops in wxRuby (since we do not support C++ data transfer there) 
-            // but we want them to always return true to prevent wxWidgets from complaining 
-            bool TransferFromWindow () override { return true; }
-            bool TransferToWindow () override { return true; }
-          };
-          __HEREDOC
-        # will be provided as a pure Ruby method
-        spec.ignore 'wxValidator::Clone'
-        # not provided in Ruby
-        spec.ignore %w[wxValidator::TransferFromWindow wxValidator::TransferToWindow]
+            }
+
+            wxObject* wxRubyValidator::Clone() const
+            {
+              bool ex_caught = false;
+              VALUE self = const_cast<wxRubyValidator*> (this)->get_self();
+              VALUE rc = wxRuby_Funcall(ex_caught, self, clone_id(), 0);
+              if (ex_caught)
+              {
+                throw Swig::DirectorRubyException(rc, self, clone_id());
+              }
+              void *ptr;
+              int res = SWIG_ConvertPtr(rc, &ptr, SWIGTYPE_p_wxValidator,  0);
+              if (!SWIG_IsOK(res)) 
+              {
+                Swig::DirectorTypeMismatchException::raise(self, "clone", SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""Wx::Validator *""'");
+              }
+              return reinterpret_cast< wxValidator * >(ptr);
+            }
+
+            void wxRubyValidator::SetWindow(wxWindow *win)
+            {
+              this->wxValidator::SetWindow(win);
+              VALUE self = this->get_self();
+              // make sure Ruby does not own this validator instance anymore
+              RDATA(self)->dfree = SWIG_RubyRemoveTracking;
+            } 
+
+            bool wxRubyValidator::TransferFromWindow() 
+            { 
+              return this->DoOnTransferFromWindow(this->DoTransferFromWindow());
+            }
+            bool wxRubyValidator::TransferToWindow() 
+            { 
+              return this->DoTransferToWindow(this->DoOnTransferToWindow());
+            }
+  
+            VALUE wxRubyValidator::DoTransferFromWindow()
+            {
+              bool ex_caught = false;
+              VALUE rc = wxRuby_Funcall(ex_caught, this->get_self(), do_transfer_from_window_id(), 0);
+              if (ex_caught)
+              {
+                throw Swig::DirectorRubyException(rc, this->get_self(), do_transfer_from_window_id());
+              }
+              return rc; 
+            } 
+            bool wxRubyValidator::DoTransferToWindow(VALUE data)
+            {
+              bool ex_caught = false;
+              VALUE rc = wxRuby_Funcall(ex_caught, this->get_self(), do_transfer_to_window_id(), 1, data);
+              if (ex_caught)
+              {
+                throw Swig::DirectorRubyException(rc, this->get_self(), do_transfer_to_window_id());
+              }
+              return (rc == Qtrue); 
+            } 
+
+            VALUE wxRubyValidator::get_self()
+            {
+              if (NIL_P(this->self_))
+              {
+                this->self_ = SWIG_RubyInstanceFor(this);
+              }
+              return this->self_;
+            }
+
+            WxRuby_ID wxRubyValidatorBinding::do_on_transfer_from_window_id("do_on_transfer_from_window");
+            WxRuby_ID wxRubyValidatorBinding::do_on_transfer_to_window_id("do_on_transfer_to_window");
+            WxRuby_ID wxRubyValidatorBinding::call_id("call");
+
+            bool wxRubyValidatorBinding::DoOnTransferFromWindow(VALUE data)
+            {
+              bool ex_caught = false;
+              VALUE rc = wxRuby_Funcall(ex_caught, this->get_self(), do_on_transfer_from_window_id(), 1, data);
+              if (ex_caught)
+              {
+                throw Swig::DirectorRubyException(rc, this->get_self(), do_on_transfer_from_window_id());
+              }
+              return (rc == Qtrue); 
+            } 
+            VALUE wxRubyValidatorBinding::DoOnTransferToWindow()
+            {
+              bool ex_caught = false;
+              VALUE rc = wxRuby_Funcall(ex_caught, this->get_self(), do_on_transfer_to_window_id(), 0);
+              if (ex_caught)
+              {
+                throw Swig::DirectorRubyException(rc, this->get_self(), do_on_transfer_to_window_id());
+              }
+              return rc; 
+            } 
+
+            bool wxRubyValidatorBinding::OnTransferFromWindow(VALUE data)
+            {
+              if (!NIL_P(this->on_transfer_from_win_proc_))
+              {
+                bool ex_caught = false;
+                VALUE rc = wxRuby_Funcall(ex_caught, this->on_transfer_from_win_proc_, call_id(), 1, data);
+                if (ex_caught)
+                {
+                  throw Swig::DirectorRubyException(rc, this->on_transfer_from_win_proc_, call_id());
+                }
+              }
+              return true; 
+            } 
+            VALUE wxRubyValidatorBinding::OnTransferToWindow()
+            {
+              if (!NIL_P(this->on_transfer_to_win_proc_))
+              {
+                bool ex_caught = false;
+                VALUE rc = wxRuby_Funcall(ex_caught, this->on_transfer_to_win_proc_, call_id(), 0);
+                if (ex_caught)
+                {
+                  throw Swig::DirectorRubyException(rc, this->on_transfer_to_win_proc_, call_id());
+                }
+                return rc;
+              }
+              return Qnil; 
+            } 
+
+            void wxRubyValidatorBinding::CopyBindings(const wxRubyValidatorBinding* val_bind)
+            {
+              if (val_bind)
+              {
+                this->on_transfer_from_win_proc_ = val_bind->on_transfer_from_win_proc_;
+                this->on_transfer_to_win_proc_ = val_bind->on_transfer_to_win_proc_;
+              }
+            }
+  
+            static void GC_mark_wxValidator(void* ptr)
+            {
+              if (ptr)
+              {
+                wxValidator* vp = reinterpret_cast<wxValidator*> (ptr);
+                wxRubyValidator* rbvp = dynamic_cast<wxRubyValidator*> (vp);
+                // This might be a pointer to the global constant wxDefaultValidator or one of it's clones 
+                // which are not wxRubyValidator-s 
+                if (rbvp) rbvp->GC_Mark();
+              }
+            } 
+            __HEREDOC
+          spec.add_swig_code '%markfunc wxValidator "GC_mark_wxValidator";'
+          # will be provided as a pure Ruby method
+          spec.ignore 'wxValidator::Clone', ignore_doc: false
+          # add wxRuby specifics
+          spec.extend_interface 'wxValidator',
+                                'wxValidator(const wxValidator& other)'
+          spec.add_extend_code 'wxValidator', <<~__HEREDOC
+            void OnTransferFromWindow(VALUE proc)
+            {
+              dynamic_cast<wxRubyValidatorBinding *>($self)->SetOnTransferFromWindow(proc);
+            } 
+            void OnTransferToWindow(VALUE proc)
+            {
+              dynamic_cast<wxRubyValidatorBinding *>($self)->SetOnTransferToWindow(proc);
+            }
+            bool DoOnTransferFromWindow(VALUE data)
+            {
+              return dynamic_cast<wxRubyValidatorBinding *>($self)->OnTransferFromWindow(data);
+            }
+            VALUE DoOnTransferToWindow()
+            {
+              return dynamic_cast<wxRubyValidatorBinding *>($self)->OnTransferToWindow();
+            }
+            __HEREDOC
+          # not provided in Ruby
+          spec.ignore %w[wxValidator::TransferFromWindow wxValidator::TransferToWindow wxValidator::SetWindow]
+        else
+          spec.add_header_code <<~__HEREDOC
+            #include "wxruby-ValidatorBinding.h"
+            __HEREDOC
+        end
+        # overrule common typemap for parent arg of Validate
+        spec.map 'wxWindow* parent' do
+          map_check code: ''
+        end
       end
     end # class Validator