wxruby3 0.9.3 → 0.9.5

data/rakelib/lib/director/static_bitmap.rb

@@ -45,6 +45,10 @@ module WXRuby3
         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
 

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'

data/rakelib/lib/director/window.rb

@@ -126,6 +126,10 @@ module WXRuby3
           else
             spec.ignore('wxWindow::SetAccessible',
                         'wxWindow::GetAccessible')
+            if Config.instance.wx_version > '3.2.4'
+              spec.ignore('wxWindow::CreateAccessible',
+                          'wxWindow::GetOrCreateAccessible')
+            end
           end
           spec.ignore_unless('USE_HOTKEY', %w[wxWindow::RegisterHotKey wxWindow::UnregisterHotKey])
           spec.ignore('wxWindow::SetSize(int, int)') # not useful as the wxSize variant will also accept an array

data/rakelib/lib/extractor/module.rb

@@ -117,6 +117,13 @@ module WXRuby3
         when 'file', 'namespace'
           Extractor.extracting_msg(kind, element, 'compoundname')
           element.xpath('sectiondef/memberdef').each { |node| self.add_element(node) }
+          # from doxygen 1.9.7 onwards some members are not included in the same XML file
+          # but referenced from another XML file; so we need to resolve such references
+          # and than add the resolved element
+          element.xpath('sectiondef/member').each do |node|
+            node = self.resolveRefId(node)
+            self.add_element(node)
+          end
 
         else
           raise ExtractorError.new('Unknown module item kind: %s' % kind)
@@ -124,6 +131,14 @@ module WXRuby3
         item
       end
 
+      def resolveRefId(node)
+        refid = node['refid'].split('_')
+        refid.pop
+        fname = File.join(Extractor.xml_dir, refid.join('_')+'.xml')
+        root = File.open(fname) {|f| Nokogiri::XML(f) }.root
+        root.at_xpath(".//sectiondef/memberdef[@id='#{node['refid']}']")
+      end
+
       # Add a new C++ function into the module that is written by hand, not
       # wrapped.
       def add_cpp_function(type, name, argsString, body, doc = nil, **kwargs)

data/rakelib/lib/generate/analyzer.rb

@@ -540,53 +540,53 @@ module WXRuby3
           # check the preprocessed definitions
           errors = []
           warnings = []
-          def_items.each do |item|
-            if Extractor::ClassDef === item && !item_ignored(item, doc_gen) &&
+          # select eligible ClassDef
+          cls_items = def_items.select do |item|
+            Extractor::ClassDef === item && !item_ignored(item, doc_gen) &&
               (!item.is_template? || template_as_class?(item.name)) &&
               !is_folded_base?(item.name)
-              intf_class_name = if item.is_template? || template_as_class?(item.name)
-                                  template_class_name(item.name)
-                                else
-                                  item.name
-                                end
-              # this should not happen
-              raise "Missing preprocessed data for class #{intf_class_name}" unless has_class_interface(intf_class_name)
-              # get the class's method registry
-              cls_mtdreg = class_interface_methods(intf_class_name)
-              # check all directly inherited generated methods
-              mtdlist = ::Set.new # remember handled signatures
-              base_list(item).each do |base_name|
-                # get 'real' base name (i.e. take renames into account)
-                base_name = ifspec.classdef_name(base_name)
-                # make sure the base class has been preprocessed
-                get_class_interface(package, base_name, doc_gen) unless has_class_interface(base_name)
-                # generate any required enum typemaps for inherited virtuals
-                gen_base_class_enum_typemaps(base_name, enum_maps)
-                # iterate the base class's method registrations
-                class_interface_methods(base_name).each_pair do |mtdsig, mtdreg|
-                  # only check on methods we have not handled yet
-                  if !mtdlist.include?(mtdsig)
-                    # did we inherit a virtual method that was not proxied in the base
-                    if mtdreg[:virtual] && !mtdreg[:proxy]
-                      # # if we did NOT generate a wrapper override and we do not have the proxy suppressed we're in trouble
-                      # if !cls_mtdreg.has_key?(mtdsig) && has_method_proxy?(item.name, mtdreg[:method])
-                      #   warnings << "* WARNING: disabling proxy for virtual method #{mtdreg[:method].signature} without wrapper implementation in class #{item.name} since it is NOT proxied in base class #{base_name}!"
-                      # els
-                      if cls_mtdreg.has_key?(mtdsig) && !cls_mtdreg[mtdsig][:extension] && !has_method_proxy?(item.name, cls_mtdreg[mtdsig][:method])
-                        # if this is not a custom extension and we do have an override wrapper and no proxy this is unnecessary code bloat
-                        warnings << " * WARNING: Unnecessary override #{mtdreg[:method].signature} in class #{item.name} for non-proxied base in #{base_name}. Ignoring."
-                        cls_mtdreg[mtdsig][:ignore] = true
-                      end
-                      # or did we inherit a virtual method that was proxied in the base
-                      # for which we DO generate a wrapper override
-                    elsif mtdreg[:virtual] && mtdreg[:proxy] && cls_mtdreg.has_key?(mtdsig)
-                      # if we do not have a proxy as well we're in trouble
-                      if !has_method_proxy?(item, mtdreg[:method])
-                        errors << "* ERROR: method #{mtdreg[:method].signature} is NOT proxied with an overriden wrapper implementation in class #{item.name} but is also implemented and proxied in base class #{base_name}!"
-                      end
+          end
+          cls_items.each do |item|
+            intf_class_name = if item.is_template? || template_as_class?(item.name)
+                                template_class_name(item.name)
+                              else
+                                item.name
+                              end
+            # this should not happen
+            raise "Missing preprocessed data for class #{intf_class_name}" unless has_class_interface(intf_class_name)
+            # get the class's method registry
+            cls_mtdreg = class_interface_methods(intf_class_name)
+            # check all directly inherited generated methods
+            mtdlist = ::Set.new # remember handled signatures
+            base_list(item).each do |base_name|
+              # make sure the base class has been preprocessed
+              get_class_interface(package, base_name, doc_gen) unless has_class_interface(base_name)
+              # generate any required enum typemaps for inherited virtuals
+              gen_base_class_enum_typemaps(base_name, enum_maps)
+              # iterate the base class's method registrations
+              class_interface_methods(base_name).each_pair do |mtdsig, mtdreg|
+                # only check on methods we have not handled yet
+                if !mtdlist.include?(mtdsig)
+                  # did we inherit a virtual method that was not proxied in the base
+                  if mtdreg[:virtual] && !mtdreg[:proxy]
+                    # # if we did NOT generate a wrapper override and we do not have the proxy suppressed we're in trouble
+                    # if !cls_mtdreg.has_key?(mtdsig) && has_method_proxy?(item.name, mtdreg[:method])
+                    #   warnings << "* WARNING: disabling proxy for virtual method #{mtdreg[:method].signature} without wrapper implementation in class #{item.name} since it is NOT proxied in base class #{base_name}!"
+                    # els
+                    if cls_mtdreg.has_key?(mtdsig) && !cls_mtdreg[mtdsig][:extension] && !has_method_proxy?(item.name, cls_mtdreg[mtdsig][:method])
+                      # if this is not a custom extension and we do have an override wrapper and no proxy this is unnecessary code bloat
+                      warnings << " * WARNING: Unnecessary override #{mtdreg[:method].signature} in class #{item.name} for non-proxied base in #{base_name}. Ignoring."
+                      cls_mtdreg[mtdsig][:ignore] = true
+                    end
+                    # or did we inherit a virtual method that was proxied in the base
+                    # for which we DO generate a wrapper override
+                  elsif mtdreg[:virtual] && mtdreg[:proxy] && cls_mtdreg.has_key?(mtdsig)
+                    # if we do not have a proxy as well we're in trouble
+                    if !has_method_proxy?(item, mtdreg[:method])
+                      errors << "* ERROR: method #{mtdreg[:method].signature} is NOT proxied with an overriden wrapper implementation in class #{item.name} but is also implemented and proxied in base class #{base_name}!"
                     end
-                    mtdlist << mtdsig
                   end
+                  mtdlist << mtdsig
                 end
               end
             end

data/rakelib/lib/generate/doc/combo_ctrl.yaml

@@ -0,0 +1,135 @@
+---
+:wxComboCtrl:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxDECLARE_EVENT_TABLE/
+          :replace: |
+            
+            ```ruby
+            class ListViewComboPopup < Wx::ListView
+            
+              include Wx::ComboPopup
+              
+              # Allow only default ctor
+              def initialize
+                # call default control ctor; need to call Wx::ListView#create later
+                super
+              end
+              
+              # Initialize member variables
+              def init
+                @value = -1
+              end
+              
+              # Create popup control
+              def create(parent)
+                # need to finish creating the list view here
+                # as calling super here would just call Wx::ComboPopup#create and not Wx::ListView#create
+                # we need to use Ruby magic
+                wx_lv_create = (Wx::ListView.instance_method :create).bind(self)
+                wx_lv_create.call(parent, 1, [0,0], Wx::DEFAULT_SIZE)
+                evt_motion :on_mouse_move
+                evt_left_up :on_mouse_click
+                end
+              
+              # Return pointer to the created control
+              def get_control
+                self
+              end
+              
+              def lv_find_item(*args)
+                unless @wx_lv_find_item
+                @wx_lv_find_item = (Wx::ListView.instance_method :find_item).bind(self)
+                end
+                @wx_lv_find_item.call(*args)
+              end
+              protected :lv_find_item
+              
+              # Translate string into a list selection
+              def set_string_value(s)
+                n = lv_find_item(-1, s)
+                if n >= 0 && n < get_item_count
+                  select(n)
+                  @value = n
+                end
+              end
+              
+              # Get list selection as a string
+              def get_string_value
+                return get_item_text(@value) if @value >= 0
+                ''
+              end
+              
+              # Do mouse hot-tracking (which is typical in list popups)
+              def on_mouse_move(event)
+                # Move selection to cursor ...
+              end
+              
+              # On mouse left up, set the value and close the popup
+              def on_mouse_click(_event)
+                @value = get_first_selected
+                
+                # Send event as well ...
+                
+                dismiss
+              end
+            
+            end
+            ```
+        - :pattern: !ruby/regexp /wxComboCtrl/
+          :replace: |
+            
+            ```ruby
+              comboCtrl = Wx::ComboCtrl.new(self, Wx::ID_ANY, '')
+              
+              popupCtrl = ListViewComboPopup.new
+              
+              # It is important to call #set_popup_control as soon as possible
+              comboCtrl.set_popup_control(popupCtrl)
+              
+              # Populate using Wx::ListView methods
+              popupCtrl.insert_item((popupCtrl.item_count, 'First Item')
+              popupCtrl.insert_item((popupCtrl.item_count, 'Second Item')
+              popupCtrl.insert_item((popupCtrl.item_count, 'Third Item')
+            ```
+:wxComboCtrl.SetMainControl:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              # Create the combo control using its default ctor.
+              combo = Wx::ComboCtrl.new
+              
+              # Create the custom main control using its default ctor too.
+              main = SomeWindow.new
+              
+              # Set the custom main control before creating the combo.
+              combo.set_main_control(main)
+              
+              # And only create it now: Wx::TextCtrl won't be unnecessarily
+              # created because the combo already has a main window.
+              combo.create(panel, Wx::ID_ANY, '')
+              
+              # Finally create the main window itself, now that its parent was
+              # created.
+              main.create(combo, ...)
+            ```
+:wxComboCtrl.SetTextCtrlStyle:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              comboCtrl = Wx::ComboCtrl.new
+              
+              # Let's make the text right-aligned
+              comboCtrl.set_text_ctrl_style(Wx::TE_RIGHT)
+              
+              comboCtrl.create(parent, Wx::ID_ANY, '')
+            ```

data/rakelib/lib/generate/doc/file_dialog_customize_hook.yaml

@@ -0,0 +1,62 @@
+---
+:wxFileDialogCustomizeHook:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+            class EncryptHook < Wx::FileDialogCustomizeHook
+            
+              attr_reader :encrypt
+            
+              # Override to add custom controls using the provided customizer object.
+              def add_custom_controls(customizer)
+                # Suppose we can encrypt files when saving them.
+                @checkbox = customizer.add_check_box('Encrypt')
+       
+                # While @checkbox is not a Wx::CheckBox, it looks almost like one
+                # and, in particular, we can bind to custom control events as usual.
+                @checkbox.evt_checkbox(Wx::ID_ANY) do |event| 
+                   # We can also call Wx::Window-like functions on them.
+                   @button.enable(event.checked?)
+                end
+       
+                # The encryption parameters can be edited in a dedicated dialog.
+                @button = customizer.add_button('Parameters...')
+                @button.evt_button(Wx::ID_ANY) do |event|
+                   # ... show the encryption parameters dialog here ...
+                end
+              end
+          
+              # Override to save the values of the custom controls.
+              def transfer_data_from_custom_controls 
+                # Save the checkbox value, as we won't be able to use it any more
+                # once this function returns.
+                @encrypt = @checkbox.get_value
+              end
+          
+            end
+            
+            # ...
+            
+            def some_method
+              Wx.FileDialog(nil, 'Save document', '', 'file.my',
+                                 'My files (*.my)|*.my',
+                                 Wx::FD_SAVE | Wx::FD_OVERWRITE_PROMPT) do |dialog|
+           
+                # This object may be destroyed before the dialog, but must remain
+                # alive until #show_modal returns.
+                customize_hook = EncryptHook.new
+                dialog.set_customize_hook(custom_hook)
+           
+                if dialog.show_modal == Wx::ID_OK 
+                  if customize_hook.encrypt 
+                    # ... save with encryption ...
+                  else
+                    # ... save without encryption ...
+                  end
+                end
+            end
+            ```

data/rakelib/lib/generate/doc/file_system.yaml

@@ -0,0 +1,28 @@
+---
+:wxFileSystemHandler.CanOpen:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /Example:/
+          :subst: ''
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxFileSystemHandler.GetMimeTypeFromExt:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /Example:/
+          :subst: ''
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxMemoryFSHandler:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /Example:/
+          :subst: ''
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''

data/rakelib/lib/generate/doc.rb

@@ -480,7 +480,7 @@ module WXRuby3
              /\A\s*Include\s+file:/           # Include file note
           ''
         else
-          para.sub!(/Include\s+file:\s+\#include\s+\<[^>]+\>\s*\Z/, '')
+          para.sub!(/Include\s+file:\s+\\?#include\s+<[^>]+> */, '')
           if event_section?
             case para
             when /The following event handler macros redirect.*(\{.*})/

data/rakelib/lib/generate/interface.rb

@@ -547,10 +547,18 @@ module WXRuby3
         if Extractor::EnumDef === item && !item.ignored && !item.items.all? {|e| e.ignored }
           fout.puts
           fout.puts "// from enum #{item.is_anonymous ? '' : item.name}"
-          fout.puts "enum #{item.name};" unless item.is_anonymous
-          item.items.each do |e|
-            unless e.ignored
-              fout.puts "%constant int #{e.name} = #{e.fqn};"
+          if item.is_anonymous
+            item.items.each do |e|
+              unless e.ignored
+                fout.puts "%constant int #{e.name} = #{e.fqn};"
+              end
+            end
+          else
+            fout.puts "enum #{item.name};"
+            item.items.each do |e|
+              unless e.ignored
+                fout.puts "%constant int #{item.name}_#{e.name} = #{e.fqn};"
+              end
             end
           end
         end

data/rakelib/lib/specs/interfaces.rb

@@ -230,6 +230,9 @@ module WXRuby3
     Director.Spec(pkg, 'wxFileSystem', requirements: %w[USE_FILESYSTEM])
     Director.Spec(pkg, 'wxDialUpManager', requirements: %w[USE_DIALUP_MANAGER])
     Director.Spec(pkg, 'wxDialUpEvent', requirements: %w[USE_DIALUP_MANAGER])
+    Director.Spec(pkg, 'wxPersistenceManager', requirements: %w[USE_CONFIG])
+    Director.Spec(pkg, 'wxPersistentObject', requirements: %w[USE_CONFIG])
+    Director.Spec(pkg, 'wxPersistentWindow', requirements: %w[USE_CONFIG])
   }
 
   Director.Package('Wx::PRT', 'USE_PRINTING_ARCHITECTURE') do |pkg|

data/rakelib/lib/swig_runner.rb

@@ -262,7 +262,7 @@ module WXRuby3
           def_items.each do |item|
             case item
             when Extractor::EnumDef
-              item.items.each { |e| enumerators[rb_wx_name(e.name)] = item } if item.is_type
+              item.items.each { |e| enumerators["#{rb_wx_name(item.name)}_#{e.name}"] = item } if item.is_type
             when Extractor::ClassDef
               item.items.select { |itm| Extractor::EnumDef === itm }.each do |enum|
                 enum.items.each { |e| enumerators[rb_wx_name(e.name)] = enum } if enum.is_type
@@ -334,6 +334,7 @@ module WXRuby3
                     fix_enum = true
                     enum_item = enum_table[md[2]]
                     enum_name = rb_wx_name(enum_item.name)
+                    enumerator_name = rb_wx_name(md[2].sub(/\A#{enum_name}_/, ''))
                     enum_id = enum_item.scope.empty? ? enum_name : "#{rb_wx_name(enum_item.scope)}::#{enum_name}"
                     enum_var = enum_id.gsub('::', '_')
                     line = [
@@ -343,7 +344,7 @@ module WXRuby3
                       # add enum class constant to current module (use unscoped name)
                       "  rb_define_const(#{md[1]}, \"#{enum_name}\", cWx#{enum_var}); // Inserted by fixmodule.rb",
                       # create enumerator value const under new enum class
-                      "  wxRuby_AddEnumValue(cWx#{enum_var}, \"#{md[2]}\"#{md[3]} // Updated by fixmodule.rb"
+                      "  wxRuby_AddEnumValue(cWx#{enum_var}, \"#{enumerator_name}\"#{md[3]} // Updated by fixmodule.rb"
                     ].join("\n")
                   end
                 else
@@ -352,13 +353,15 @@ module WXRuby3
                     # of the same enum?
                     if enum_item && enum_table[md[2]] == enum_item
                       enum_name = rb_wx_name(enum_item.name)
+                      enumerator_name = rb_wx_name(md[2].sub(/\A#{enum_name}_/, ''))
                       enum_id = enum_item.scope.empty? ? enum_name : "#{rb_wx_name(enum_item.scope)}::#{enum_name}"
                       enum_var = enum_id.gsub('::', '_')
                       # create enumerator value const under new enum class
-                      line = "  wxRuby_AddEnumValue(cWx#{enum_var}, \"#{md[2]}\"#{md[3]} // Updated by fixmodule.rb"
+                      line = "  wxRuby_AddEnumValue(cWx#{enum_var}, \"#{enumerator_name}\"#{md[3]} // Updated by fixmodule.rb"
                     else # we found the start of another enum
                       enum_item = enum_table[md[2]]
                       enum_name = rb_wx_name(enum_item.name)
+                      enumerator_name = rb_wx_name(md[2].sub(/\A#{enum_name}_/, ''))
                       enum_id = enum_item.scope.empty? ? enum_name : "#{rb_wx_name(enum_item.scope)}::#{enum_name}"
                       enum_var = enum_id.gsub('::', '_')
                       line = [
@@ -368,7 +371,7 @@ module WXRuby3
                         # add enum class constant to current module (use unscoped name)
                         "  rb_define_const(#{md[1]}, \"#{enum_name}\", cWx#{enum_var}); // Inserted by fixmodule.rb",
                         # create enumerator value const under new enum class
-                        "  wxRuby_AddEnumValue(cWx#{enum_var}, \"#{md[2]}\"#{md[3]} // Updated by fixmodule.rb"
+                        "  wxRuby_AddEnumValue(cWx#{enum_var}, \"#{enumerator_name}\"#{md[3]} // Updated by fixmodule.rb"
                       ].join("\n")
                     end
                   else # end of enum def

data/rakelib/lib/typemap/combo_popup.rb

@@ -0,0 +1,42 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxComboPopup typemap definition
+###
+
+require_relative '../core/mapping'
+
+module WXRuby3
+
+  module Typemap
+
+    module ComboPopup
+
+      include Typemap::Module
+
+      define do
+
+        # for DoSetPopupControl
+        map 'wxComboPopup* popup' => 'Wx::ComboPopup,nil' do
+
+          add_header_code <<~__CODE
+            #include <wx/combo.h>
+            
+            WXRUBY_EXPORT wxComboPopup* wxRuby_ComboPopupFromRuby(VALUE popup);
+            WXRUBY_EXPORT VALUE wxRuby_ComboPopupToRuby(wxComboPopup* popup);
+            __CODE
+
+          map_in code: '$1 = wxRuby_ComboPopupFromRuby($input);'
+
+          map_directorin code: '$input = wxRuby_ComboPopupToRuby($1);'
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/typemap/config.rb

@@ -44,6 +44,14 @@ module WXRuby3
             $input = wxRuby_ConfigBase2Ruby($1);
             __CODE
 
+          map_out code: <<~__CODE
+            $result = wxRuby_ConfigBase2Ruby($1);
+            __CODE
+
+          map_directorout code: <<~__CODE
+            $result = wxRuby_Ruby2ConfigBase($1); 
+            __CODE
+
         end
 
       end

data/samples/widgets/widgets.rb

@@ -456,12 +456,10 @@ module Widgets
   
       @panel.set_sizer(sizerTop)
 
-      # TODO - review wxPersistenceManager
-      # sizeSet = wxPersistentRegisterAndRestore(this, "Main")
-  
+      sizeSet = Wx.persistent_register_and_restore(self, "Main")
+
       sizeMin = @panel.get_best_size
-      # if ( !sizeSet )
-         set_client_size(sizeMin)
+      set_client_size(sizeMin) unless sizeSet
       set_min_client_size(sizeMin)
 
       # connect the event handlers
@@ -1068,10 +1066,8 @@ module Widgets
         evt_choicebook_page_changed(ID::Widgets_BookCtrl, :on_page_changed)
       end
 
-      # TODO - review wxPersistenceManager
-      # const bool pageSet = wxPersistentRegisterAndRestore(m_book)
-      pageSet = false
-  
+      pageSet = Wx.persistent_register_and_restore(@book)
+
       if Wx.has_feature?(:USE_TREEBOOK)
         # for treebook page #0 is empty parent page only so select the first page
         # with some contents