wxruby3 0.9.2 → 0.9.3

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
 

data/rakelib/lib/director/window.rb

@@ -66,8 +66,6 @@ module WXRuby3
             __CODE
           end
           spec.ignore [
-            'wxWindow::TransferDataFromWindow',
-            'wxWindow::TransferDataToWindow',
             'wxWindow::PopEventHandler',
             'wxWindow::SetConstraints',
             'wxWindow::GetHandle',
@@ -81,6 +79,9 @@ module WXRuby3
             'wxWindow::SendIdleEvents',
             'wxWindow::ClientToScreen(int*,int*)', # no need; prefer the wxPoint version
             'wxWindow::ScreenToClient(int*,int*)', # no need; prefer the wxPoint version
+            # provide (non-virtual) renamed alternatives (prevent Ruby keyword/standard clash)
+            'wxWindow::Raise',
+            'wxWindow::Lower'
           ]
           # no real docs and can't find actual examples of usage; ignore
           spec.ignore 'wxWindow::GetConstraints', 'wxWindow::SetConstraints'
@@ -91,6 +92,15 @@ module WXRuby3
             map_check code: ''
           end
           spec.add_extend_code 'wxWindow', <<~__HEREDOC
+            void raise_window()
+            {
+              $self->Raise();
+            }  
+            void lower_window()
+            {
+              $self->Lower();
+            }  
+
             static wxWindow* find_window_by_id(long id, const wxWindow *find_from_parent=0)
             {
               return wxWindow::FindWindowById(id, find_from_parent);
@@ -269,9 +279,13 @@ module WXRuby3
                           "#{spec.class_name(citem)}::SetAcceleratorTable",
                           "#{spec.class_name(citem)}::SetBackgroundColour",
                           "#{spec.class_name(citem)}::SetBackgroundStyle",
+                          "#{spec.class_name(citem)}::HasTransparentBackground",
                           "#{spec.class_name(citem)}::SetCursor",
                           "#{spec.class_name(citem)}::SetFocus",
                           "#{spec.class_name(citem)}::SetFocusFromKbd",
+                          "#{spec.class_name(citem)}::AcceptsFocus",
+                          "#{spec.class_name(citem)}::AcceptsFocusRecursively",
+                          "#{spec.class_name(citem)}::AcceptsFocusFromKeyboard",
                           "#{spec.class_name(citem)}::SetFont",
                           "#{spec.class_name(citem)}::SetForegroundColour",
                           "#{spec.class_name(citem)}::SetHelpText",

data/rakelib/lib/extractor/function.rb

@@ -95,8 +95,9 @@ module WXRuby3
         params_doc.unlink if params_doc
         # get brief doc
         doc = xml_trans.to_doc(@brief_doc, item: self)
+        doc << "\n" if @detailed_doc # force empty line (paragraph break) between summary and detail
         # add detailed doc text without params doc
-        doc << xml_trans.to_doc(@detailed_doc, item: self, desc: :detail)
+        doc << xml_trans.to_doc(@detailed_doc, item: self, desc: :detail) if @detailed_doc
         # get mapped ruby parameter list
         params = []
         mapped_ret_args = nil

data/rakelib/lib/generate/analyzer.rb

@@ -366,7 +366,7 @@ module WXRuby3
         type_list = [type]
         type_list << "#{enum_scope}::#{type.split('::').pop}" unless enum_scope.empty?
         rb_enum_name = if !enum_scope.empty?
-                         "#{enum_scope}::#{rb_wx_name(type.split('::').pop)}"
+                         "#{rb_wx_name(enum_scope)}::#{rb_wx_name(type.split('::').pop)}"
                        else
                          rb_wx_name(type)
                        end

data/rakelib/lib/generate/doc.rb

@@ -253,7 +253,7 @@ module WXRuby3
             <div class="wxrb-remark">
             <b>Remark:</b>
             <p>#{node_to_doc(node)}</p>
-            </div>>
+            </div>
           __NOTE
         else
           node_to_doc(node)
@@ -861,6 +861,7 @@ module WXRuby3
 
     def get_class_doc(cls)
       doc = @xml_trans.to_doc(cls.brief_doc, item: cls)
+      doc << "\n" if cls.detailed_doc # force empty line (paragraph break) between summary and detail
       doc << @xml_trans.to_doc(cls.detailed_doc, item: cls, desc: :detail) if cls.detailed_doc
       doc
     end
@@ -900,6 +901,8 @@ module WXRuby3
                   fdoc.doc.indent { gen_item_requirements(fdoc, ovl) }
                 end
                 fdoc.puts "def #{name}(*args) end"
+                # in case all overloads were ignored there will be no SWIG generated alias
+                no_gen_alias = docs.all? { |ovl, _, _| ovl.ignored }
               else
                 mtd, params, doc = docs.shift
                 fdoc.doc.puts doc
@@ -909,9 +912,11 @@ module WXRuby3
                 else
                   fdoc.puts "def #{name}(#{params}) end"
                 end
+                # in case the documented method was ignored there will be no SWIG generated alias
+                no_gen_alias = mtd.ignored
               end
-              # check for SWIG generated aliases
-              if alias_methods.has_key?(cm.name)
+              # check for SWIG generated aliases (skip ignored method defs as these will not have SWIG generated aliases)
+              if !no_gen_alias && alias_methods.has_key?(cm.name)
                 fdoc.puts "alias_method :#{alias_methods[cm.name]}, :#{name}"
               else
                 # check for aliases that will be available from WxRubyStyleAccessors at runtime
@@ -920,7 +925,8 @@ module WXRuby3
                              when /\Aget_(\w+)/
                                $1
                              when /\Aset_(\w+)/
-                               if mtd_head.all.any? { |ovl| ovl.parameter_count > 0 && ovl.required_param_count < 2 }
+                               # only document alias if at least 1 method overload has a single required argument
+                               if docs.any? { |ovl, _, _| ovl.parameter_count > 0 && ovl.required_param_count < 2 }
                                  "#{$1}="
                                else
                                  nil

data/rakelib/lib/specs/interfaces.rb

@@ -56,6 +56,7 @@ module WXRuby3
     Director.Spec(pkg, 'wxCaret')
     Director.Spec(pkg, 'wxValidator', requirements: %[USE_VALIDATORS])
     Director.Spec(pkg, 'wxTextValidator', requirements: %[USE_VALIDATORS])
+    Director.Spec(pkg, 'wxNumValidator', requirements: %[USE_VALIDATORS])
     Director.Spec(pkg, 'wxAccelerator', requirements: %w[USE_ACCEL])
     Director.Spec(pkg, 'wxMenuItem', requirements: %w[USE_MENUS])
     Director.Spec(pkg, 'wxMenuBar', requirements: %w[USE_MENUBAR])
@@ -80,6 +81,7 @@ module WXRuby3
     Director.Spec(pkg, 'wxComboBox', requirements: %w[USE_COMBOBOX])
     Director.Spec(pkg, 'wxBitmapComboBox', requirements: %w[USE_BITMAPCOMBOBOX])
     Director.Spec(pkg, 'wxComboCtrl', requirements: %w[USE_COMBOCTRL])
+    Director.Spec(pkg, 'wxOwnerDrawnComboBox', requirements: %w[USE_ODCOMBOBOX ])
     Director.Spec(pkg, 'wxRadioBox', requirements: %w[USE_RADIOBOX])
     Director.Spec(pkg, 'wxPanel')
     Director.Spec(pkg, 'wxWithImages')

data/rakelib/lib/swig_runner.rb

@@ -404,29 +404,63 @@ module WXRuby3
             dir_cls_re_txt = class_list.select { |clsdef| has_proxy?(clsdef) }.collect { |cd| cd.name }.join('|')
             # create regexp for Director constructors (may not exist if no proxies are enabled)
             dir_ctor_re = /SwigDirector_\w+::SwigDirector_\w+\(.*\)\s*:\s*(#{dir_cls_re_txt})\(.*\)\s*,\s*Swig::Director.*{/
+            # create regexp for method wrappers other than 'initialize' wrappers
+            wrap_mtd_re = /_wrap_(#{cls_re_txt})_(\w+)\(.*\)/
           end
           found_new = false
           cpp_class = nil
           cpp_new_re = nil
+          found_wrap_mtd = false
+          wrap_mtd_name = nil
+          wrap_mtd_upcall_re = nil
           update_source do |line|
             if found_new # inside 'initialize' wrapper?
               if cpp_new_re =~ line # at C++ allocation of class instance?
-                # replace with the registered implementation class
-                line.sub!(/new\s+#{cpp_class}\(/, "new #{class_implementation(cpp_class)}(")
-                found_new = false # only 1 line will match per wrapper function so stop matching
+                if $1 # director allocation for derived class
+                  # in case of copy ctor replace type of argument
+                  # for director copy ctor
+                  line.sub!(/\((\w+),\s*\(#{cpp_class}\s+const\s+\&\)/, "(\\1,(#{class_implementation(cpp_class)} const &)")
+                else # allocation for actual class
+                  # replace with the registered implementation class
+                  line.sub!(/new\s+#{cpp_class}\(/, "new #{class_implementation(cpp_class)}(")
+                  # in case of copy ctor also replace type of argument
+                  # for class copy ctor
+                  line.sub!(/\(\(#{cpp_class}\s+const\s+\&\)/, "((#{class_implementation(cpp_class)} const &)")
+                end
               elsif /\A}/ =~ line # end of wrapper function?
                 # stop matching (in case of overloads there will be one matching wrapper function
                 # that does no actual allocation but just acts as a front for the overload wrappers)
                 found_new = false
               end
+            elsif found_wrap_mtd
+              if wrap_mtd_upcall_re =~ line # at upcall for possibly proxied wrapper?
+                line.gsub!(cpp_class, class_implementation(cpp_class))
+                # if the upcall does not yet cast the receiver instance to the correct implementation class
+                if /\((\w+)\)->/ =~ line
+                  # add required cast
+                  line.sub!(/\((\w+)\)->/, "((#{class_implementation(cpp_class)} *)\\1)->")
+                end
+                found_wrap_mtd = false # upcall found
+              elsif /\A}/ =~ line
+                found_wrap_mtd = false # end of wrapper method
+              end
             elsif new_re =~ line # are we at an 'initialize' wrapper?
               found_new = true
               cpp_class = $1
-              cpp_new_re = /new\s+#{cpp_class}\(.*\)/ # regexp for C++ new expression for this specific class
-            elsif proxies_enabled && dir_ctor_re =~ line # at director ctor?
-              # replace base class name by implementation name
-              cpp_class = $1
-              line.sub!(/:\s*#{cpp_class}\(/, ": #{class_implementation(cpp_class)}(")
+              cpp_new_re = /new\s+(SwigDirector_)?#{cpp_class}\(.*\)/ # regexp for C++ new expression for this specific class
+            elsif proxies_enabled
+              if dir_ctor_re =~ line # at director ctor?
+                # replace base class name by implementation name
+                cpp_class = $1
+                line.sub!(/:\s*#{cpp_class}\(/, ": #{class_implementation(cpp_class)}(")
+                # in case of copy ctor also replace type of argument
+                line.sub!(/\(VALUE\s+self,\s*#{cpp_class}\s+const\s+\&(\w+)\)/, "(VALUE self, #{class_implementation(cpp_class)} const &\\1)")
+              elsif wrap_mtd_re =~ line # at wrapper method other than 'initialize' wrapper
+                cpp_class = $1
+                wrap_mtd_name = $2
+                wrap_mtd_upcall_re = /-\>#{cpp_class}::#{wrap_mtd_name}\(/
+                found_wrap_mtd = true
+              end
             end
             line
           end
@@ -435,11 +469,23 @@ module WXRuby3
             # if so, we also need to update the header code (Director class declaration)
             # create regexp for 'initialize' wrappers (due to overloads this could be more than one per class)
             dir_re = /class\s+SwigDirector_\w+\s*:\s*public\s+(#{dir_cls_re_txt})\s*,\s*public\s+Swig::Director\s*{/
+            found_dir = false
+            copy_ctor_re = nil
             update_header do |line|
-              if dir_re =~ line # at Director class declaration?
+              if found_dir
+                if copy_ctor_re =~ line
+                  # replace copy ctor arg type
+                  arg = $1
+                  line.sub!(/#{cpp_class}\s+const\s+&#{arg}/, "#{class_implementation(cpp_class)} const &#{arg}")
+                elsif /\A};/ =~ line
+                  found_dir = false
+                end
+              elsif dir_re =~ line # at Director class declaration?
                 # replace base class name by implementation name
                 cpp_class = $1
                 line.sub!(/public\s+#{cpp_class}/, "public #{class_implementation(cpp_class)}")
+                copy_ctor_re = /SwigDirector_#{cpp_class}\(VALUE\s+self,\s*#{cpp_class}\s+const\s+&(\w+)\);/
+                found_dir = true
               end
               line
             end

data/rakelib/lib/typemap/client_data.rb

@@ -0,0 +1,67 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 client data typemap definition
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    module ClientData
+
+      include Typemap::Module
+
+      define do
+
+        map 'wxClientData *' => 'Object' do
+          add_header_code <<~__CODE
+            #include "wxruby-ClientData.h"
+            __CODE
+          map_in code: '$1 = NIL_P($input) ? nullptr : new wxRubyClientData($input);'
+          map_out code: <<~__CODE
+            $result = Qnil;
+            if ($1)
+            {
+              wxRubyClientData* rbcd = dynamic_cast<wxRubyClientData*> ($1);
+              if (rbcd) $result = rbcd->GetData();
+            }
+          __CODE
+
+          map_typecheck precedence: 'POINTER', code: '$1 = true;'
+        end
+
+        map 'wxObject *userData' => 'Object' do
+          add_header_code <<~__CODE
+            #include "wxruby-ClientData.h"
+            __CODE
+          map_in code: '$1 = NIL_P($input) ? nullptr : new wxRubyUserData($input);'
+
+          map_typecheck precedence: 'POINTER', code: '$1 = true;'
+        end
+
+        # WxUserDataObject must be typedef for wxObject*
+        map 'WxUserDataObject' => 'Object' do
+
+          map_out code: <<~__CODE
+            $result = Qnil;
+            if ($1)
+            {
+              wxRubyUserData* rbud = dynamic_cast<wxRubyUserData*> ($1);
+              if (rbud) $result = rbud->GetData();
+            }
+          __CODE
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/typemap/common.rb

@@ -211,7 +211,8 @@ module WXRuby3
 
         map 'wxSize&' => 'Array(Integer, Integer), Wx::Size',
             'wxPoint&' => 'Array(Integer, Integer), Wx::Point' do
-          map_in code: <<~__CODE
+          add_header_code '#include <memory>'
+          map_in temp: 'std::unique_ptr<$1_basetype> tmp', code: <<~__CODE
             if ( TYPE($input) == T_DATA )
             {
               void* argp$argnum;
@@ -222,8 +223,7 @@ module WXRuby3
             {
               $1 = new $1_basetype( NUM2INT( rb_ary_entry($input, 0) ),
                                    NUM2INT( rb_ary_entry($input, 1) ) );
-              // Create a ruby object so the C++ obj is freed when GC runs
-              SWIG_NewPointerObj($1, $1_descriptor, 1);
+              tmp.reset($1); // auto destruct when method scope ends 
             }
             else
             {

data/rakelib/lib/typemap/datetime.rb

@@ -42,7 +42,7 @@ module WXRuby3
           map_directorin code: '$input = wxRuby_wxDateTimeToRuby($1);'
 
           map_typecheck precedence: 'SWIGOBJECT', code: <<~__CODE
-            $1 = rb_obj_is_kind_of($input, rb_cTime) || rb_respond_to($input, rb_intern ("to_time"));
+            $1 = NIL_P($input) || rb_obj_is_kind_of($input, rb_cTime) || rb_respond_to($input, rb_intern ("to_time"));
             __CODE
         end
 

data/rakelib/lib/typemap/tree_itemid.rb

@@ -50,7 +50,7 @@ module WXRuby3
 
           map_in temp: 'wxTreeItemId tmpId', code: <<~__CODE
             if ($input != Qnil) tmpId = _wxRuby_Unwrap_wxTreeItemId($input);
-            $1 = &tmpId;
+            $1 = tmpId;
             __CODE
 
           map_directorin code: '$input = _wxRuby_Wrap_wxTreeItemId($1);'
@@ -59,7 +59,7 @@ module WXRuby3
 
           map_directorout temp: 'wxTreeItemId tmpId', code: <<~__CODE
             if ($input != Qnil) tmpId = _wxRuby_Unwrap_wxTreeItemId($input);
-            $result = &tmpId;
+            $result = tmpId;
           __CODE
 
           map_typecheck precedence: 'POINTER', code: '$1 = _wxRuby_Is_wxTreeItemId($input);'