wxruby3 0.9.1 → 0.9.3

data/rakelib/lib/director/num_validator.rb

@@ -0,0 +1,495 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+require_relative './validator'
+
+module WXRuby3
+
+  class Director
+
+    class NumValidator < Validator
+
+      def setup
+        spec.items.replace ['valnum.h'] # enum from XML but only manually defined custom wxRuby classes
+        super
+        spec.initialize_at_end = true # no inheritance/XML info to analyze
+        spec.ignore 'wxMakeIntegerValidator', 'wxMakeFloatingPointValidator'
+        # need to explicitly declare this here as we do not have any XML extracted items
+        # so the post processing of the EvtHandler director does not work
+        spec.add_header_code <<~__HEREDOC
+          static WxRuby_ID __wxrb_try_before_id("try_before");
+          static WxRuby_ID __wxrb_try_after_id("try_after");
+          __HEREDOC
+        # provide custom wxRuby numeric validator classes
+        spec.add_header_code <<~__HEREDOC
+          #include <wx/valnum.h>
+
+          #ifdef wxLongLong_t
+              typedef wxLongLong_t LongestValueType;
+              typedef wxULongLong_t ULongestValueType;
+          #else
+              typedef long LongestValueType;
+              typedef unsigned long ULongestValueType;
+          #endif
+          class WXIntegerValidator : public wxIntegerValidator<LongestValueType>, public wxRubyValidatorBinding
+          {
+          public:
+            WXIntegerValidator(const WXIntegerValidator& v) 
+              : wxIntegerValidator(v)
+              , wxRubyValidatorBinding(v)
+            {
+              // this is horrible but why they needed to explicitly declare this as a const member is beyond me
+              *reinterpret_cast<LongestValueType**> ((void*)&m_value) = &m_valueCache;
+            }
+            WXIntegerValidator(long style=wxNUM_VAL_DEFAULT) 
+              : wxIntegerValidator(&m_valueCache, style) 
+            {}
+            WXIntegerValidator(LongestValueType min, LongestValueType max, long style=wxFILTER_NONE) 
+              : wxIntegerValidator(&m_valueCache, min, max, style) 
+            {}
+            virtual ~WXIntegerValidator() 
+            {
+              wxRuby_ReleaseEvtHandlerProcs(this);
+            }
+
+            virtual wxObject* Clone() const override
+            {
+              WXIntegerValidator* clone = new WXIntegerValidator(*this);
+              clone->m_valueCache = this->m_valueCache;
+              return clone;
+            }
+
+            virtual void SetWindow(wxWindow *win) override
+            {
+              this->wxIntegerValidator::SetWindow(win);
+              VALUE self = 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->wxIntegerValidator::TransferFromWindow())
+              {
+                // ok, data is retrieved from window and cached
+                // now allow any defined binding handler to pass on the data
+                return this->DoOnTransferFromWindow(LL2NUM(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 = NUM2LL(data);
+              }
+              // now allow standard functionality to transfer to window 
+              return this->wxIntegerValidator::TransferToWindow();
+            }
+
+            LongestValueType GetValue () const
+            {
+              return m_valueCache;
+            }
+
+            void SetValue (LongestValueType val)
+            {
+              m_valueCache = val;
+            }
+
+          protected:
+            static VALUE c_IntegerValidator; 
+
+            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_IntegerValidator))
+                {
+                  c_IntegerValidator = rb_const_get(mWxCore, rb_intern("IntegerValidator"));
+                }
+                swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(c_IntegerValidator);
+                  this->self_ = SWIG_NewPointerObj(this, swig_type, 0); // wrap but don't make Ruby own it
+                }
+              }
+              return this->self_; 
+            }
+  
+            LongestValueType m_valueCache {};         
+          };
+
+          VALUE WXIntegerValidator::c_IntegerValidator = Qnil;
+
+          static void GC_mark_wxIntegerValidator(void* ptr)
+          {
+            if (ptr)
+            {
+              wxValidator* vp = reinterpret_cast<wxValidator*> (ptr);
+              WXIntegerValidator* rbvp = dynamic_cast<WXIntegerValidator*> (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();
+            }
+          } 
+
+          class WXUnsignedValidator : public wxIntegerValidator<ULongestValueType>, public wxRubyValidatorBinding
+          {
+          public:
+            WXUnsignedValidator(const WXUnsignedValidator& v) 
+              : wxIntegerValidator(v)
+              , wxRubyValidatorBinding(v)
+            {
+              // this is horrible but why they needed to explicitly declare this as a const member is beyond me
+              *reinterpret_cast<ULongestValueType**> ((void*)&m_value) = &m_valueCache;
+            }
+            WXUnsignedValidator(long style=wxFILTER_NONE) 
+              : wxIntegerValidator(&m_valueCache, style) 
+            {}
+            WXUnsignedValidator(LongestValueType min, LongestValueType max, long style=wxFILTER_NONE) 
+              : wxIntegerValidator(&m_valueCache, min, max, style) 
+            {}
+            virtual ~WXUnsignedValidator() 
+            {
+              wxRuby_ReleaseEvtHandlerProcs(this);
+            }               
+
+            virtual wxObject* Clone() const override
+            {
+              WXUnsignedValidator* clone = new WXUnsignedValidator(*this);
+              clone->m_valueCache = this->m_valueCache;
+              return clone;
+            }
+
+            virtual void SetWindow(wxWindow *win) override
+            {
+              this->wxIntegerValidator::SetWindow(win);
+              VALUE self = 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->wxIntegerValidator::TransferFromWindow())
+              {
+                // ok, data is retrieved from window and cached
+                // now allow any defined binding handler to pass on the data
+                return this->DoOnTransferFromWindow(ULL2NUM(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 = NUM2ULL(data);
+              }
+              // now allow standard functionality to transfer to window 
+              return this->wxIntegerValidator::TransferToWindow();
+            }
+
+            ULongestValueType GetValue () const
+            {
+              return m_valueCache;
+            }
+
+            void SetValue (ULongestValueType val)
+            {
+              m_valueCache = val;
+            }
+
+          protected:
+            static VALUE c_UnsignedValidator; 
+
+            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_UnsignedValidator))
+                  {
+                    c_UnsignedValidator = rb_const_get(mWxCore, rb_intern("UnsignedValidator"));
+                  }
+                  swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(c_UnsignedValidator);
+                  this->self_ = SWIG_NewPointerObj(this, swig_type, 0); // wrap but don't make Ruby own it
+                }
+              }
+              return this->self_; 
+            }
+
+            ULongestValueType m_valueCache {};         
+          };
+
+          VALUE WXUnsignedValidator::c_UnsignedValidator = Qnil;
+
+          static void GC_mark_wxUnsignedValidator(void* ptr)
+          {
+            if (ptr)
+            {
+              wxValidator* vp = reinterpret_cast<wxValidator*> (ptr);
+              WXUnsignedValidator* rbvp = dynamic_cast<WXUnsignedValidator*> (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();
+            }
+          } 
+
+          class WXFloatValidator : public wxFloatingPointValidator<double>, public wxRubyValidatorBinding
+          {
+          public:
+            WXFloatValidator(const WXFloatValidator& v) 
+              : wxFloatingPointValidator(v)
+              , wxRubyValidatorBinding(v)
+            {
+              // this is horrible but why they needed to explicitly declare this as a const member is beyond me
+              *reinterpret_cast<double**> ((void*)&m_value) = &m_valueCache;
+            }
+            WXFloatValidator(long style=wxFILTER_NONE) 
+              : wxFloatingPointValidator(&m_valueCache, style) 
+            {}
+            WXFloatValidator(int precision, long style=wxFILTER_NONE) 
+              : wxFloatingPointValidator(precision, &m_valueCache, style) 
+            {}
+            virtual ~WXFloatValidator() 
+            {
+              wxRuby_ReleaseEvtHandlerProcs(this);
+            }               
+
+            virtual wxObject* Clone() const override
+            {
+              return new WXFloatValidator(*this);
+            }
+
+            virtual void SetWindow(wxWindow *win) override
+            {
+              this->wxFloatingPointValidator::SetWindow(win);
+              VALUE self = 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->wxFloatingPointValidator::TransferFromWindow())
+              {
+                // ok, data is retrieved from window and cached
+                // now allow any defined binding handler to pass on the data
+                return this->DoOnTransferFromWindow(DBL2NUM(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 = NUM2DBL(data);
+              }
+              // now allow standard functionality to transfer to window 
+              return this->wxFloatingPointValidator::TransferToWindow();
+            }
+
+            double GetValue () const
+            {
+              return m_valueCache;
+            }
+
+            void SetValue (double val)
+            {
+              m_valueCache = val;
+            }
+
+          protected:
+            static VALUE c_FloatValidator; 
+
+            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_FloatValidator))
+                  {
+                    c_FloatValidator = rb_const_get(mWxCore, rb_intern("FloatValidator"));
+                  }
+                  swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(c_FloatValidator);
+                  this->self_ = SWIG_NewPointerObj(this, swig_type, 0); // wrap but don't make Ruby own it
+                }
+              }
+              return this->self_; 
+            }
+
+            double m_valueCache {};         
+          };
+
+          VALUE WXFloatValidator::c_FloatValidator = Qnil;
+
+          static void GC_mark_wxFloatValidator(void* ptr)
+          {
+            if (ptr)
+            {
+              wxValidator* vp = reinterpret_cast<wxValidator*> (ptr);
+              WXFloatValidator* rbvp = dynamic_cast<WXFloatValidator*> (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 'GC_MANAGE_AS_OBJECT(WXIntegerValidator);',
+                           '%markfunc WXIntegerValidator "GC_mark_wxIntegerValidator";',
+                           'GC_MANAGE_AS_OBJECT(WXUnsignedValidator);',
+                           '%markfunc WXUnsignedValidator "GC_mark_wxUnsignedValidator";',
+                           'GC_MANAGE_AS_OBJECT(WXFloatValidator);',
+                           '%markfunc WXFloatValidator "GC_mark_wxFloatValidator";'
+        spec.new_object 'WXIntegerValidator::Clone',
+                        'WXUnsignedValidator::Clone',
+                        'WXFloatValidator::Clone'
+        spec.suppress_warning(473,
+                              'WXIntegerValidator::Clone',
+                              'WXUnsignedValidator::Clone',
+                              'WXFloatValidator::Clone')
+        spec.map_apply 'long long * OUTPUT' => ['wxLongLong_t& min', 'wxLongLong_t& max']
+        spec.map_apply 'unsigned long long * OUTPUT' => ['wxULongLong_t& min', 'wxULongLong_t& max']
+        spec.map_apply 'double * OUTPUT' => ['double& min', 'double& max']
+        spec.swig_import 'swig/classes/include/wxObject.h'
+        spec.swig_import 'swig/classes/include/wxEvtHandler.h'
+        spec.swig_import 'swig/classes/include/wxValidator.h'
+        # hardcoded interface declarations
+        spec.add_interface_code <<~__HEREDOC
+          // Bit masks used for numeric validator styles.
+          enum wxNumValidatorStyle
+          {
+              wxNUM_VAL_DEFAULT               = 0x0,
+              wxNUM_VAL_THOUSANDS_SEPARATOR   = 0x1,
+              wxNUM_VAL_ZERO_AS_BLANK         = 0x2,
+              wxNUM_VAL_NO_TRAILING_ZEROES    = 0x4
+          };
+
+          %alias WXIntegerValidator::GetMin "min";
+          %alias WXIntegerValidator::SetMin "min=";
+          %alias WXIntegerValidator::GetMax "max";
+          %alias WXIntegerValidator::SetMax "max=";
+          %alias WXIntegerValidator::SetStyle "style=";
+          %alias WXIntegerValidator::GetValue "value";
+          %alias WXIntegerValidator::SetValue "value=";
+
+          class WXIntegerValidator : public wxValidator
+          {
+          public:
+            WXIntegerValidator(const WXIntegerValidator& v); 
+            WXIntegerValidator(long style=wxNUM_VAL_DEFAULT); 
+            WXIntegerValidator(wxLongLong_t min, wxLongLong_t max, long style=wxFILTER_NONE); 
+            virtual ~WXIntegerValidator(); 
+
+            virtual WXIntegerValidator* Clone() const;
+
+            void SetMin(wxLongLong_t min);
+            wxLongLong_t GetMin() const;
+            void SetMax(wxLongLong_t max);
+            wxLongLong_t GetMax() const;
+            void SetRange(wxLongLong_t min, wxLongLong_t max);
+            void GetRange(wxLongLong_t& min, wxLongLong_t& max) const;
+            void SetStyle(int style);
+
+            // wxRuby extensions
+            wxLongLong_t GetValue () const;
+            void SetValue (wxLongLong_t val);
+          };
+
+          %alias WXUnsignedValidator::GetMin "min";
+          %alias WXUnsignedValidator::SetMin "min=";
+          %alias WXUnsignedValidator::GetMax "max";
+          %alias WXUnsignedValidator::SetMax "max=";
+          %alias WXUnsignedValidator::SetStyle "style=";
+          %alias WXUnsignedValidator::GetValue "value";
+          %alias WXUnsignedValidator::SetValue "value=";
+          
+          class WXUnsignedValidator : public wxValidator
+          {
+          public:
+            WXUnsignedValidator(const WXUnsignedValidator& v); 
+            WXUnsignedValidator(long style=wxNUM_VAL_DEFAULT); 
+            WXUnsignedValidator(wxULongLong_t min, wxULongLong_t max, long style=wxFILTER_NONE); 
+            virtual ~WXUnsignedValidator(); 
+
+            virtual WXUnsignedValidator* Clone() const;
+
+            void SetMin(wxULongLong_t min);
+            wxULongLong_t GetMin() const;
+            void SetMax(wxULongLong_t max);
+            wxULongLong_t GetMax() const;
+            void SetRange(wxULongLong_t min, wxULongLong_t max);
+            void GetRange(wxULongLong_t& min, wxULongLong_t& max) const;
+            void SetStyle(int style);
+
+            // wxRuby extensions
+            wxULongLong_t GetValue () const;
+            void SetValue (wxULongLong_t val);
+          };          
+
+          %alias WXFloatValidator::GetMin "min";
+          %alias WXFloatValidator::SetMin "min=";
+          %alias WXFloatValidator::GetMax "max";
+          %alias WXFloatValidator::SetMax "max=";
+          %alias WXFloatValidator::SetStyle "style=";
+          %alias WXFloatValidator::GetValue "value";
+          %alias WXFloatValidator::SetValue "value=";
+          
+          class WXFloatValidator : public wxValidator
+          {
+          public:
+            WXFloatValidator(const WXFloatValidator& v); 
+            WXFloatValidator(long style=wxNUM_VAL_DEFAULT); 
+            WXFloatValidator(int precision, long style); 
+            virtual ~WXFloatValidator(); 
+
+            virtual WXFloatValidator* Clone() const;
+
+            void SetMin(double min);
+            double GetMin() const;
+            void SetMax(double max);
+            double GetMax() const;
+            void SetRange(double min, double max);
+            void GetRange(double& min, double& max) const;
+            void SetStyle(int style);
+
+            void SetPrecision(unsigned precision);
+            void SetFactor(double factor);
+
+            // wxRuby extensions
+            double GetValue () const;
+            void SetValue (double val);
+          };          
+          __HEREDOC
+      end
+    end # class NumValidator
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/numeric_property_validator.rb

@@ -6,31 +6,156 @@
 # wxRuby3 wxWidgets interface director
 ###
 
-require_relative './event_handler'
+require_relative './validator'
 
 module WXRuby3
 
   class Director
 
-    class NumericPropertyValidator < EvtHandler
+    class NumericPropertyValidator < Validator
 
       def setup
         super
         # need a custom implementation to handle event handler proc cleanup
         spec.add_header_code <<~__HEREDOC
-          class WXRubyNumericPropertyValidator : public wxNumericPropertyValidator
+          class WXRubyNumericPropertyValidator : public wxNumericPropertyValidator, public wxRubyValidatorBinding
           {
           public:
             WXRubyNumericPropertyValidator(NumericType numericType, int base=10) 
-              : wxNumericPropertyValidator(numericType, base) {}
+              : wxNumericPropertyValidator(numericType, base) 
+            {
+              m_stringValue = &m_valueCache;
+            }
+            WXRubyNumericPropertyValidator(const WXRubyNumericPropertyValidator& other) 
+              : wxNumericPropertyValidator(other)
+              , wxRubyValidatorBinding(other) 
+            {
+              m_stringValue = &m_valueCache;
+            }
             virtual ~WXRubyNumericPropertyValidator() 
             {
               wxRuby_ReleaseEvtHandlerProcs(this);
             }               
+
+            virtual wxObject* Clone() const override
+            {
+              WXRubyNumericPropertyValidator *clone = new WXRubyNumericPropertyValidator(*this);
+              clone->m_valueCache = this->m_valueCache;
+              return clone;
+            }
+
+            virtual void SetWindow(wxWindow *win) override
+            {
+              this->wxNumericPropertyValidator::SetWindow(win);
+              VALUE self = 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->wxNumericPropertyValidator::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->wxNumericPropertyValidator::TransferToWindow();
+            }
+
+            const wxString& GetValue () const
+            {
+              return m_valueCache;
+            }
+
+            void SetValue (const wxString& val)
+            {
+              m_valueCache = val;
+            }
+
+          private:
+            static VALUE c_NumericPropertyValidator; 
+
+            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_NumericPropertyValidator))
+                  {
+                    c_NumericPropertyValidator = rb_eval_string("Wx::PG::NumericPropertyValidator");
+                  }
+                  swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(c_NumericPropertyValidator);
+                  this->self_ = SWIG_NewPointerObj(this, swig_type, 0); // wrap but don't make Ruby own it
+                }
+              }
+              return this->self_; 
+            }
+
+            wxString m_valueCache;               
           };
-        __HEREDOC
+
+          VALUE WXRubyNumericPropertyValidator::c_NumericPropertyValidator = Qnil;
+
+          static void GC_mark_wxNumericPropertyValidator(void* ptr)
+          {
+            if (ptr)
+            {
+              wxValidator* vp = reinterpret_cast<wxValidator*> (ptr);
+              WXRubyNumericPropertyValidator* rbvp = dynamic_cast<WXRubyNumericPropertyValidator*> (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 wxValidator "GC_mark_wxValidator";'
+        # make Ruby director and wrappers use custom implementation
         spec.use_class_implementation 'wxNumericPropertyValidator', 'WXRubyNumericPropertyValidator'
-        spec.no_proxy 'wxNumericPropertyValidator::Clone'
+        spec.new_object 'wxNumericPropertyValidator::Clone'
+        # add wxRuby extensions
+        spec.add_extend_code 'wxNumericPropertyValidator', <<~__HEREDOC
+          VALUE GetValue()
+          {
+            WXRubyNumericPropertyValidator* rb_self = dynamic_cast<WXRubyNumericPropertyValidator*> ($self);
+            if (rb_self)
+              return WXSTR_TO_RSTR(rb_self->GetValue());
+            else
+              return Qnil;
+          }
+
+          void SetValue(const wxString& val)
+          {
+            WXRubyNumericPropertyValidator* rb_self = dynamic_cast<WXRubyNumericPropertyValidator*> ($self);
+            if (rb_self)
+              rb_self->SetValue(val);
+          }
+          __HEREDOC
+        # handle clone mapping
+        spec.map 'wxObject *' => 'Wx::PG::NumericPropertyValidator' do
+          map_out code: <<~__CODE
+            $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), SWIGTYPE_p_wxTextValidator, SWIG_POINTER_OWN);
+            __CODE
+        end
+        spec.suppress_warning(473, 'wxNumericPropertyValidator::Clone')
+        spec.extend_interface 'wxNumericPropertyValidator',
+                              'wxNumericPropertyValidator(const wxNumericPropertyValidator &other)'
         spec.do_not_generate :variables, :defines, :enums, :functions
       end