wxruby3 1.6.1 → 1.8.0

data/rakelib/lib/director/shared_evt_handler.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+module WXRuby3
+
+  class Director
+
+    class SharedEvtHandler < Director
+
+      def setup
+        super
+        spec.items.clear
+        spec.add_header_code <<~__HEREDOC
+          #include "wxruby-SharedEventHandler.h"
+          __HEREDOC
+        spec.add_init_code <<~__HEREDOC
+          wx_setup_WxRubySharedEvtHandler(mWxRT);
+          __HEREDOC
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/director/sizer.rb

@@ -56,11 +56,10 @@ module WXRuby3
             {
               if ($self->Detach(szr))
               {
-                VALUE rb_szr = SWIG_RubyInstanceFor(szr);
-                if (rb_szr && !NIL_P(rb_szr))
+                if (!RB_NIL_P(SWIG_RubyInstanceFor(szr)))
                 {
-                  // transfer ownership to Ruby
-                  RDATA(rb_szr)->dfree = GcSizerFreeFunc;            
+                  // have SWIG transfer ownership of Ruby value       
+                  SWIG_NewPointerObj(szr, SWIGTYPE_p_wxSizer, SWIG_POINTER_OWN);
                 }
                 return true;
               }
@@ -72,20 +71,12 @@ module WXRuby3
               wxSizerItem* itm = $self->GetItem(itm_nr);
               if (itm)
               {
-                VALUE rb_szr = Qnil;
-                if (itm->IsSizer())
-                {
-                  rb_szr = SWIG_RubyInstanceFor(itm->GetSizer());
-                }
-                if ($self->Detach(itm_nr))
-                {
-                  if (rb_szr && !NIL_P(rb_szr))
-                  {
-                    // transfer ownership to Ruby
-                    RDATA(rb_szr)->dfree = GcSizerFreeFunc;            
-                  }
-                  return true;
+                if (itm->IsSizer() && !RB_NIL_P(SWIG_RubyInstanceFor(itm->GetSizer())))
+                { 
+                  // have SWIG transfer ownership of Ruby value       
+                  SWIG_NewPointerObj(itm->GetSizer(), SWIGTYPE_p_wxSizer, SWIG_POINTER_OWN);
                 }
+                return $self->Detach(itm_nr);
               }
               return false;
             }

data/rakelib/lib/director/sizer_item.rb

@@ -46,11 +46,10 @@ module WXRuby3
             {
               if ($self->IsSizer())
               {
-                VALUE rb_szr = SWIG_RubyInstanceFor($self->GetSizer());
-                if (rb_szr && !NIL_P(rb_szr))
+                if (!RB_NIL_P(SWIG_RubyInstanceFor($self->GetSizer())))
                 {
-                  // transfer ownership to Ruby
-                  RDATA(rb_szr)->dfree = GcSizerFreeFunc;            
+                  // have SWIG transfer ownership of Ruby value       
+                  SWIG_NewPointerObj($self->GetSizer(), SWIGTYPE_p_wxSizer, SWIG_POINTER_OWN);
                 }
                 $self->DetachSizer();
               }              

data/rakelib/lib/director/task_bar_icon.rb

@@ -35,31 +35,37 @@ module WXRuby3
         # this one is protected so ignored by default but we want it here
         # (we do not want GetPopupMenu available for override in Ruby)
         spec.regard %w[wxTaskBarIcon::CreatePopupMenu]
-        # This is used for CreatePopupMenu, a virtual method which is
-        # overridden in user subclasses of TaskBarIcon to create the menu over
-        # the icon.
-        #
-        # The Wx::Menu needs to be protected from GC so the typemap stores the
-        # object returned by the ruby method in an instance variable so it's
-        # marked. It also handles the special case where +nil+ is returned, to
-        # signal to Wx that no menu is to be shown.
+        if Config.instance.wx_version_check('3.1.5') >= 0
+          spec.regard %w[wxTaskBarIcon::GetPopupMenu]
+        end
+        # This is used for CreatePopupMenu and possibly GetPopupMenu, virtual methods which can be
+        # overridden in user subclasses of TaskBarIcon to provide the menu over the icon.
+        # In the case of GetPopupMenu the menu will be used but not deleted so it can be stored in
+        # a member variable and reused.
+        # In the case of CreatePopupMenu the menu is disowned and deleted after use. The Wx::Menu Ruby
+        # instance than needs to be protected from GC so the typemap stores the object returned by the
+        # ruby method in an instance variable so it's marked as long as the TaskBarIcon exists.
+        # It also handles the special case where +nil+ is returned, to signal to Wx that no menu is to
+        # be shown.
         spec.map 'wxMenu *' do
           map_directorout code: <<~__CODE
-            rb_iv_set(swig_get_self(), "@__popmenu__", $1);
+            static const std::string create_popup_menu("CreatePopupMenu");
+            bool disown = (std::string("$symname") == create_popup_menu);
+            if (disown) rb_iv_set(swig_get_self(), "@__popupmenu__", $1);
             if (NIL_P($1))
             {
-              $result = NULL;
+              $result = nullptr;
             }
             else
             {
               void * ptr;
-              int swig_res = SWIG_ConvertPtr(result, &ptr, $1_descriptor, 0 | SWIG_POINTER_DISOWN);
+              int swig_res = SWIG_ConvertPtr(result, &ptr, $1_descriptor, disown ? SWIG_POINTER_DISOWN : 0);
               if (!SWIG_IsOK(swig_res))
               {
                 Swig::DirectorTypeMismatchException::raise(swig_get_self(), "$symname", rb_eTypeError,
                          "create_popup_menu must return a Wx::Menu, or nil");
               }
-              $result = reinterpret_cast < wxMenu * > (ptr);
+              $result = static_cast <wxMenu *> (ptr);
             }
             __CODE
         end

data/rakelib/lib/director/text_validator.rb

@@ -32,7 +32,16 @@ module WXRuby3
             }
             virtual ~WXRubyTextValidator() 
             {
+              // All Validators are EvtHandlers, so prevent any pending events being
+              // sent after destruction (otherwise ObjectPreviouslyDeleted errors result)
+              this->SetEvtHandlerEnabled(false);
               wxRuby_ReleaseEvtHandlerProcs(this);
+              // Disassociate the C++ and Ruby objects if not done by Ruby free method
+              if (!NIL_P(SWIG_RubyInstanceFor(this)))
+              {
+                SWIG_RubyUnlinkObjects(this);
+                SWIG_RubyRemoveTracking(this);
+              }
             }
 
             virtual wxObject* Clone() const override

data/rakelib/lib/director/thread_event.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+require_relative './event'
+
+module WXRuby3
+
+  class Director
+
+    class ThreadEvent < Event
+
+      def setup
+        super
+        spec.gc_as_marked # use marked so doc gen does not mark it as untracked (what it actually is)
+        spec.ignore 'wxThreadEvent::GetPayload',
+                    'wxThreadEvent::SetPayload',
+                    'wxThreadEvent::GetEventCategory'
+        spec.ignore 'wxThreadEvent::wxThreadEvent'
+        spec.regard 'wxThreadEvent::wxThreadEvent', regard_doc: false
+        spec.add_swig_code %Q{%constant wxEventType wxEVT_THREAD = wxEVT_THREAD;}
+        spec.do_not_generate(:variables, :defines, :enums, :functions)
+      end
+
+    end # class ThreadEvent
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/tip_window.rb

@@ -19,12 +19,123 @@ module WXRuby3
         spec.disable_proxies
         spec.ignore 'wxTipWindow::SetTipWindowPtr'
         spec.ignore 'wxTipWindow::wxTipWindow'
-        spec.add_extend_code 'wxTipWindow', <<~__HEREDOC
-          wxTipWindow(wxWindow* parent, const wxString& text, wxCoord maxLength = 100)
-          {
-            return new wxTipWindow(parent, text, maxLength);
-          }   
-          __HEREDOC
+        if Config.instance.wx_version_check('3.3.2') >= 0
+          spec.ignore 'wxTipWindow::Create'
+          # need to re-implement this
+          spec.ignore 'wxTipWindow::New', ignore_doc: false
+          # Rubified version
+          spec.add_extend_code 'wxTipWindow', <<~__HEREDOC
+            static VALUE New(wxWindow* parent, const wxString& text, wxCoord maxLength = 100, wxRect* rectBounds = nullptr)
+            {
+                wxTipWindow::Ref tipRef = wxTipWindow::New(parent, text, maxLength, rectBounds);   
+
+                return SWIG_NewPointerObj((new wxTipWindow::Ref(std::move(tipRef))), SWIGTYPE_p_wxTipWindow__Ref, SWIG_POINTER_OWN |  0 );
+            }
+            __HEREDOC
+          # add Ruby-style methods
+          spec.add_extend_code 'wxTipWindow::Ref', <<~__HEREDOC
+            VALUE is_ok()
+            {
+                return *$self ? Qtrue : Qfalse;
+            }
+ 
+            wxTipWindow* get_tip_window()
+            {
+                return $self->Ref::operator->();
+            }
+            __HEREDOC
+          # and aliases
+          spec.add_swig_code '%alias wxTipWindow::Ref::is_ok "ok?";'
+          spec.add_swig_code '%alias wxTipWindow::Ref::get_tip_window "tip_window";'
+          spec.rename_for_ruby 'TipWindow_Ref' => 'wxTipWindow::Ref'
+          spec.rename_for_ruby 'new_tip' => 'wxTipWindow::New'
+        else
+          spec.make_abstract 'wxTipWindow'
+          # provide custom wxRuby reference class
+          spec.add_header_code <<~__HEREDOC
+            class WXTipWindow_Ref
+            {
+              public:
+                WXTipWindow_Ref() {}
+                WXTipWindow_Ref& operator=(WXTipWindow_Ref&& o)
+                {
+                    if (_ptr != o._ptr)
+                    {
+                        if (_ptr)
+                        {
+                            _ptr->SetTipWindowPtr(nullptr);
+                        }
+                
+                        _ptr = o._ptr;
+                        if (_ptr)
+                        {
+                            o._ptr = nullptr;
+                            _ptr->SetTipWindowPtr(&_ptr);
+                        }
+                    }
+                    return *this;
+                }
+
+                bool is_ok()
+                {
+                    return _ptr ? true : false;
+                }
+     
+                wxTipWindow* get_tip_window()
+                {
+                    return _ptr;
+                }
+
+                wxTipWindow* _ptr = {};  
+            };
+            __HEREDOC
+          spec.add_swig_code <<~__HEREDOC
+            %alias WXTipWindow_Ref::is_ok "ok?";
+            %alias WXTipWindow_Ref::get_tip_window "tip_window";
+
+            class WXTipWindow_Ref
+            {
+              private:
+                WXTipWindow_Ref();
+
+              public:
+                bool is_ok();
+     
+                wxTipWindow* get_tip_window();
+            };
+            __HEREDOC
+          # add constructor method
+          spec.add_extend_code 'wxTipWindow', <<~__HEREDOC
+            static VALUE New_Tip(wxWindow* parent, const wxString& text, wxCoord maxLength = 100, wxRect* rectBounds = nullptr)
+            {
+                std::unique_ptr<WXTipWindow_Ref> retval(new WXTipWindow_Ref);
+                std::unique_ptr<wxTipWindow> temp(new wxTipWindow(parent, text, maxLength, &retval->_ptr, rectBounds));
+                retval->_ptr = temp.release();
+            
+                return SWIG_NewPointerObj(retval.release(), SWIGTYPE_p_WXTipWindow_Ref, SWIG_POINTER_OWN |  0 );
+            }
+            __HEREDOC
+        end
+      end
+
+      def doc_generator
+        TipWindowDocGenerator.new(self)
+      end
+
+    end
+
+    class TipWindowDocGenerator < DocGenerator
+
+      def gen_class_doc_members(fdoc, clsdef, cls_members, alias_methods)
+        super
+        fdoc.doc.puts 'Constructs a new TipWindow object which is immediately shown.'
+        fdoc.doc.puts 'Returns a {Wx::TipWindow::Ref}.'
+        fdoc.doc.puts '@param parent [Wx::Window] parent window (not nil).'
+        fdoc.doc.puts '@param text [String] The text to show, may contain the new line characters.'
+        fdoc.doc.puts '@param maxLength [Integer] The length of each line, in pixels. Set to a very large value to avoid wrapping lines.'
+        fdoc.doc.puts '@param rectBounds [Wx::Rect] If given, passed to {Wx::TipWindow#set_bounding_rect}, please see its documentation for the description of this parameter.'
+        fdoc.doc.puts '@return [Wx::TipWindow::Ref] weak tip window reference'
+        fdoc.puts 'def self.new_tip(parent, text, maxLength = 100, rectBounds = nil) end'
       end
 
     end

data/rakelib/lib/director/tool_bar.rb

@@ -33,6 +33,8 @@ module WXRuby3
           wxToolBarToolBase::Attach
           ]
         spec.no_proxy 'wxToolBarToolBase'
+        # for SetDropdownMenu
+        spec.disown 'wxMenu *'
         # more sensible name to use
         spec.rename_for_ruby('ToolBarTool' => 'wxToolBarToolBase')
         spec.map 'wxToolBarBase *' => 'Wx::ToolBar' do
@@ -73,6 +75,10 @@ module WXRuby3
           'wxToolBar::AddTool(wxToolBarToolBase *)',
           'wxToolBar::InsertTool(size_t,wxToolBarToolBase *)'
           ]
+        if Config.instance.features_set?('WXOSX')
+          spec.extend_interface('wxToolBar',
+                                'virtual bool Destroy() override')
+        end
       end
     end # class Object
 

data/rakelib/lib/director/validator.rb

@@ -37,7 +37,16 @@ module WXRuby3
             {}
             wxRubyValidator::~wxRubyValidator ()
             {
+              // All Validators are EvtHandlers, so prevent any pending events being
+              // sent after destruction (otherwise ObjectPreviouslyDeleted errors result)
+              this->SetEvtHandlerEnabled(false);
               wxRuby_ReleaseEvtHandlerProcs(this);
+              // Disassociate the C++ and Ruby objects if not done by Ruby free method
+              if (!NIL_P(SWIG_RubyInstanceFor(this)))
+              {
+                SWIG_RubyUnlinkObjects(this);
+                SWIG_RubyRemoveTracking(this);
+              }
             }
 
             wxObject* wxRubyValidator::Clone() const
@@ -45,7 +54,9 @@ module WXRuby3
               VALUE self = const_cast<wxRubyValidator*> (this)->get_self();
               VALUE rc = wxRuby_Funcall(self, clone_id(), 0);
               void *ptr;
-              int res = SWIG_ConvertPtr(rc, &ptr, SWIGTYPE_p_wxValidator,  0);
+              // disown the validator for this is a C++ return and when this is called by a window
+              // to set it's validator that window will manage the validator
+              int res = SWIG_ConvertPtr(rc, &ptr, SWIGTYPE_p_wxValidator,  SWIG_POINTER_DISOWN);
               if (!SWIG_IsOK(res)) 
               {
                 Swig::DirectorTypeMismatchException::raise(self, "clone", SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""Wx::Validator *""'");
@@ -147,6 +158,9 @@ module WXRuby3
           spec.add_swig_code '%markfunc wxValidator "GC_mark_wxValidator";'
           # will be provided as a pure Ruby method
           spec.ignore 'wxValidator::Clone', ignore_doc: false
+          # ignore default ctor docs
+          spec.ignore 'wxValidator::wxValidator'
+          spec.regard 'wxValidator::wxValidator', regard_doc: false # only use interface spec, not docs
           # add wxRuby specifics
           spec.extend_interface 'wxValidator',
                                 'wxValidator(const wxValidator& other)'

data/rakelib/lib/director/variant.rb

@@ -384,48 +384,69 @@ module WXRuby3
         # provide a custom wxVariantData implementation for Ruby VALUE
         # and some interface extensions to use that from Ruby
         spec.add_header_code <<~__HEREDOC
+          WXRUBY_TRACE_GUARD(WxRubyTraceGCMarkVariant, "GC_MARK_VARIANT")
+          WXRUBY_TRACE_GUARD(WxRubyTraceGCTrackVariant, "GC_TRACK_VARIANT")
+
           class WXRBValueVariantData;
-          // Mapping of WXRBValueVariantData* to Ruby VALUE
-          WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
-                                      WXRBVariantDataToRbValueHash);
-          static WXRBVariantDataToRbValueHash Variant_Value_Map;
 
-          static void wxRuby_markRbValueVariants()
+          static const std::string WXRUBY_VARIANT_DATA = { "WXRUBY_VARIANT_DATA" };
+
+          static void GC_mark_RbValueVariants(const TGCTrackingValueMap& values)
           {
-            WXRBVariantDataToRbValueHash::iterator it;
-            for( it = Variant_Value_Map.begin(); it != Variant_Value_Map.end(); ++it )
+            WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
+              WXRUBY_TRACE("> GC_mark_RbValueVariants")
+            WXRUBY_TRACE_END
+
+            for(const auto& ti : values)
             {
-              VALUE obj = it->second;
-          #ifdef __WXRB_DEBUG__
-              if (wxRuby_TraceLevel()>1)
-              {
-                void *c_ptr = (TYPE(obj) == T_DATA ? DATA_PTR(obj) : 0);
-                std::wcout << "**** wxRuby_markRbValueVariants : " << it->first << "|" << (void*)c_ptr << std::endl;
-              }
-          #endif 
+              VALUE obj = ti.second;
+
+              WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
+                WXRUBY_TRACE_WITH(void *c_ptr = (TYPE(obj) == T_DATA ? DATA_PTR(obj) : 0))
+                WXRUBY_TRACE("| GC_mark_RbValueVariants : " << ti.first << "|" << (void*)c_ptr)
+              WXRUBY_TRACE_END
+
               rb_gc_mark(obj);
             }
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
+              WXRUBY_TRACE("< GC_mark_RbValueVariants")
+            WXRUBY_TRACE_END
           }
 
           static void wxRuby_RegisterValueVariantData(void* ptr, VALUE rbval)
           {
-          #ifdef __WXRB_DEBUG__
-            if (wxRuby_TraceLevel()>1)
+            static bool is_marker_registered = false;
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackVariant, 2)
+              WXRUBY_TRACE_WITH(void *c_ptr = (TYPE(rbval) == T_DATA ? DATA_PTR(rbval) : 0))
+              WXRUBY_TRACE("> wxRuby_RegisterValueVariantData : " << ptr << "|" << (void*)c_ptr)
+            WXRUBY_TRACE_END
+
+            if (!is_marker_registered)
             {
-              void *c_ptr = (TYPE(rbval) == T_DATA ? DATA_PTR(rbval) : 0);
-              std::wcout << "**** wxRuby_RegisterValueVariantData : " << ptr << "|" << (void*)c_ptr << std::endl;
-            } 
-          #endif 
-            Variant_Value_Map[ptr] = rbval;
+              wxRuby_RegisterTrackingCategory(WXRUBY_VARIANT_DATA, GC_mark_RbValueVariants, true);
+              is_marker_registered = true;
+            }
+
+            wxRuby_RegisterCategoryValue(WXRUBY_VARIANT_DATA, ptr, rbval);
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
+              WXRUBY_TRACE("< wxRuby_RegisterValueVariantData")
+            WXRUBY_TRACE_END
           }
 
           static void wxRuby_UnregisterValueVariantData(void* ptr)
           {
-          #ifdef __WXRB_DEBUG__
-            if (wxRuby_TraceLevel()>1)
-              std::wcout << "**** wxRuby_UnregisterValueVariantData : " << ptr << std::endl; 
-          #endif 
-            Variant_Value_Map.erase(ptr);
+            WXRUBY_TRACE_IF(WxRubyTraceGCTrackVariant, 2)
+              WXRUBY_TRACE("> wxRuby_UnregisterValueVariantData : " << ptr)
+            WXRUBY_TRACE_END
+
+            wxRuby_UnregisterCategoryValue(WXRUBY_VARIANT_DATA, ptr);
+
+            WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
+              WXRUBY_TRACE("< wxRuby_UnregisterValueVariantData")
+            WXRUBY_TRACE_END
           }
 
           class WXRUBY_EXPORT WXRBValueVariantData : public wxVariantData
@@ -486,7 +507,6 @@ module WXRuby3
             return variant;
           }
           __HEREDOC
-        spec.add_init_code 'wxRuby_AppendMarker(wxRuby_markRbValueVariants);'
         # ignore GetType (not doc)
         spec.ignore 'wxVariant::GetType', ignore_doc: false
         # replace with custom implementation

data/rakelib/lib/director/vlistbox.rb

@@ -16,34 +16,37 @@ module WXRuby3
 
       def setup
         super
-        if Config.instance.wx_version_check('3.3.0') > 0
+        spec.gc_as_window
+        if Config.instance.wx_version_check('3.3.1') > 0
+          spec.override_inheritance_chain('wxVListBox', [{ 'wxVScrolledCanvas' => 'wxVScrolledCanvas' }, 'wxWindow', 'wxEvtHandler', 'wxObject'])
+        elsif Config.instance.wx_version_check('3.3.0') > 0
           spec.override_inheritance_chain('wxVListBox', [{ 'wxVScrolledWindow' => 'wxVScrolledWindow' }, 'wxPanel', 'wxWindow', 'wxEvtHandler', 'wxObject'])
         else
           spec.override_inheritance_chain('wxVListBox', [{ 'wxVScrolledWindow' => 'wxHScrolledWindow' }, 'wxPanel', 'wxWindow', 'wxEvtHandler', 'wxObject'])
         end
         spec.make_abstract 'wxVListBox'
         # provide base implementations for OnDrawItem and OnMeasureItem
-        spec.add_header_code <<~__HEREDOC
-          // Custom subclass implementation. 
-          class wxRubyVListBox : public wxVListBox
-          {
-          public:
-            wxRubyVListBox() 
-              : wxVListBox () {}
-            wxRubyVListBox(wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=0, const wxString &name=wxVListBoxNameStr)
-              : wxVListBox(parent, id, pos, size, style, name) {}
-          protected:
-            virtual void OnDrawItem(wxDC&, const wxRect&, size_t) const
-            {
-            }
-            virtual wxCoord OnMeasureItem(size_t) const
-            {
-              return {};
-            }
-          };
-        __HEREDOC
-        # make Ruby director and wrappers use custom implementation
-        spec.use_class_implementation('wxVListBox', 'wxRubyVListBox')
+        # spec.add_header_code <<~__HEREDOC
+        #   // Custom subclass implementation.
+        #   class wxRubyVListBox : public wxVListBox
+        #   {
+        #   public:
+        #     wxRubyVListBox()
+        #       : wxVListBox () {}
+        #     wxRubyVListBox(wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=0, const wxString &name=wxVListBoxNameStr)
+        #       : wxVListBox(parent, id, pos, size, style, name) {}
+        #   protected:
+        #     virtual void OnDrawItem(wxDC&, const wxRect&, size_t) const
+        #     {
+        #     }
+        #     virtual wxCoord OnMeasureItem(size_t) const
+        #     {
+        #       return {};
+        #     }
+        #   };
+        # __HEREDOC
+        # # make Ruby director and wrappers use custom implementation
+        # spec.use_class_implementation('wxVListBox', 'wxRubyVListBox')
         # make sure protected methods are included
         spec.regard 'wxVListBox::OnDrawItem',
                     'wxVListBox::OnMeasureItem',