wxruby3 0.9.0.pre.rc.3 → 0.9.1

data/rakelib/lib/generate/analyzer.rb

@@ -1,6 +1,9 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
 ###
 # wxRuby3 base interface Analyzer class
-# Copyright (c) M.J.N. Corino, The Netherlands
 ###
 
 require 'monitor'
@@ -360,41 +363,47 @@ module WXRuby3
 
       def gen_enum_typemap(type)
         enum_scope = Extractor::EnumDef.enum_scope(type)
-        type_list = enum_scope.empty? ? [type] : [type, "#{enum_scope}::#{type}"]
-        rb_enum_name = rb_wx_name(type)
-        director.spec.map *type_list, as: rb_enum_name do
+        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)}"
+                       else
+                         rb_wx_name(type)
+                       end
+        STDERR.puts "*** #{director.spec.module_name}: defining type map for #{type_list} as: Wx::#{rb_enum_name}" if Director.trace?
+        director.spec.map *type_list, as: "Wx::#{rb_enum_name}" do
           map_in code: <<~__CODE
             int eval;
-            if (!wxRuby_GetEnumValue("#{type}", $input, eval))
+            if (!wxRuby_GetEnumValue("#{rb_enum_name}", $input, eval))
             {
               VALUE str = rb_inspect($input);
               rb_raise(rb_eArgError,
                        "Invalid enum class. Expected %s got %s.",
-                       "#{rb_enum_name}",
+                       "Wx::#{rb_enum_name}",
                        StringValuePtr(str));
             }
             $1 = static_cast<$1_type>(eval);
-            __CODE
+          __CODE
           map_out code: <<~__CODE
-            $result = wxRuby_GetEnumValueObject("#{type}", static_cast<int>($1));
-            __CODE
+            $result = wxRuby_GetEnumValueObject("#{rb_enum_name}", static_cast<int>($1));
+          __CODE
           map_typecheck precedence: 1, code: <<~__CODE
-            $1 = wxRuby_IsEnumValue("#{type}", $input);
-            __CODE
+            $1 = wxRuby_IsEnumValue("#{rb_enum_name}", $input);
+          __CODE
           map_directorin code: <<~__CODE
-            $input = wxRuby_GetEnumValueObject("#{type}", static_cast<int>($1));
+            $input = wxRuby_GetEnumValueObject("#{rb_enum_name}", static_cast<int>($1));
             if ($input == Qnil)
             {
               Swig::DirectorTypeMismatchException::raise(rb_eArgError, 
-                                                         "Invalid enum value for enum class #{rb_enum_name}.");
+                                                         "Invalid enum value for enum class Wx::#{rb_enum_name}.");
             }
           __CODE
           map_directorout code: <<~__CODE
             int eval;
-            if (!wxRuby_GetEnumValue("#{type}", $input, eval))
+            if (!wxRuby_GetEnumValue("#{rb_enum_name}", $input, eval))
             {
               Swig::DirectorTypeMismatchException::raise(rb_eTypeError, 
-                                                         "Invalid enum. Expected #{rb_enum_name}.");
+                                                         "Invalid enum. Expected Wx::#{rb_enum_name}.");
             }
             $result = static_cast<$1_type>(eval);
           __CODE
@@ -402,7 +411,7 @@ module WXRuby3
       end
 
       def gen_function_enum_typemaps(fndef, enum_maps)
-        if !(Extractor::MethodDef === fndef && fndef.is_ctor) &&
+        if !(Extractor::MethodDef === fndef && (fndef.is_ctor || fndef.type.nil?)) &&
               Extractor::EnumDef.enum?(fndef.type) &&
               !enum_maps.include?(fndef.type)
           gen_enum_typemap(fndef.type)
@@ -411,7 +420,7 @@ module WXRuby3
         fndef.parameters.each do |param|
           if Extractor::EnumDef.enum?(param.type) && !enum_maps.include?(param.type)
             gen_enum_typemap(param.type)
-            enum_maps << fndef.type
+            enum_maps << param.type
           end
         end
       end
@@ -554,10 +563,11 @@ module WXRuby3
                   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])
-                        errors << "* ERROR: method #{mtdreg[:method].signature} is proxied without wrapper implementation in class #{item.name} but not proxied in base class #{base_name}!"
-                      elsif cls_mtdreg.has_key?(mtdsig) && !cls_mtdreg[mtdsig][:extension] && !has_method_proxy?(item.name, cls_mtdreg[mtdsig][:method])
+                      # # 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

data/rakelib/lib/generate/base.rb

@@ -1,6 +1,9 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
 ###
 # wxRuby3 base Generator class
-# Copyright (c) M.J.N. Corino, The Netherlands
 ###
 
 require_relative '../core/spec_helper'

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

@@ -0,0 +1,15 @@
+---
+:wxAnimationBundle:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              animationCtrl = Wx::AnimationCtrl.new(parent, Wx::ID_ANY)
+              animations = Wx::AnimationBundle.new 
+              animations.add("throbber.gif")
+              animations.add("throbber_2x.gif")
+              animationCtrl.play if animationCtrl.set_animation(animations)
+            ```

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

@@ -57,6 +57,16 @@
               if event.get_modifiers == Wx::KeyModifier::MOD_CONTROL
                 # ... handle Ctrl-XXX ...
             ```
+:wxKeyEvent.GetRawKeyCode:
+  :detail:
+    :post:
+      - :pattern: !ruby/regexp /,\s+use\s+\#ifdef\s+\{Wx::HAS_RAW_KEY_CODES\}.*available\./
+        :subst: '.'
+:wxKeyEvent.GetRawKeyFlags:
+  :detail:
+    :post:
+      - :pattern: !ruby/regexp /,\s+use\s+\#ifdef\s+\{Wx::HAS_RAW_KEY_CODES\}.*available\./
+        :subst: '.'
 :wxMouseEvent.GetModifiers:
   :detail:
     :pre:
@@ -114,10 +124,6 @@
                   vb_pt = get_view_start # Top left corner of client
                 
                   Wx::RegionIterator.for_region(get_update_region) do |region_it|
-            
-                    int vX,vY,vW,vH                 
-                    wxRegionIterator upd(GetUpdateRegion()) # get the update rect list
-                
                     region_it.each do |rct|
                       # rct == Dimensions of client area to repaint in pixels
                 

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

@@ -0,0 +1,21 @@
+---
+:wxGridCellAttr.GetNonDefaultAlignment:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              h_align, v_align = attr.get_non_default_alignment
+              h_align = Wx::ALIGN_RIGHT if h_align == Wx::ALIGN_INVALID
+            ```
+
+    :post:
+      - :pattern: !ruby/regexp /Unlike\s.*\{Wx::Alignment::ALIGN_INVALID\}\./
+        :subst: 'Unlike {Wx::GRID::GridCellAttr#get_alignment} this function only returns hAlign and vAlign if this attribute does define a non-default alignment. Otherwise the returned value will be {Wx::ALIGN_INVALID}.'
+:wxGridCellAttr.GetAlignment:
+  :detail:
+    :post:
+      - :pattern: !ruby/regexp /Notice\s.*desirable\./
+        :subst: 'Notice that valid hAlign and vAlign values (default or non-default) are always returned by this function, use {Wx::GRID::GridCellAttr#get_non_default_alignment} if this is not desirable.'

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

@@ -0,0 +1,25 @@
+---
+:wxGrid.GetRowGridLinePen:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MidiGrid < Wx::GRID::Grid
+            
+                # ...
+            
+                # in a grid displaying music notation, use a solid black pen between
+                # octaves (C0=row 127, C1=row 115 etc.)
+                def get_row_grid_line_pen(row)
+                  if row % 12 == 7 
+                    Wx::Pen.new(Wx::BLACK, 1, Wx::PENSTYLE_SOLID)
+                  else
+                    get_default_grid_line_pen
+                  end
+                end
+            
+              end
+            ```

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

@@ -0,0 +1,11 @@
+---
+:wxHtmlContainerCell.SetWidthFloat.w:
+  :brief:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              set_width_float(-50, Wx::HTML::HTML_UNITS_PIXELS)
+            ```

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

@@ -0,0 +1,23 @@
+---
+:wxHtmlHelpController.AddBook:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              add_book('help.zip')
+            ```
+:wxHtmlHelpController.SetViewer:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              @help.set_viewer('kdehelp')
+              @help.set_viewer('gnome-help-browser')
+              @help.set_viewer('netscape', Wx::HELP_NETSCAPE)
+            ```

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

@@ -0,0 +1,21 @@
+---
+:wxHtmlHelpWindow:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              # @embeddedHelpWindow is a wxHtmlHelpWindow
+              # @embeddedHtmlHelp is a wxHtmlHelpController
+              #   
+              # Create embedded HTML Help window
+              @embeddedHelpWindow = Wx::HTML::HtmlHelpWindow.new
+              @embeddedHtmlHelp.use_config(config, rootPath) # Set your own config object here
+              @embeddedHtmlHelp.set_help_window(@embeddedHelpWindow)
+              @embeddedHelpWindow.create(self, Wx::ID_ANY, 
+                                         size: get_client_size,
+                                         style: Wx::TAB_TRAVERSAL|Wx::BORDER_NONE)
+              @embeddedHtmlHelp.add_book('doc.zip')
+            ```

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

@@ -0,0 +1,47 @@
+---
+:wxHtmlFilter.CanRead:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFilter < Wx::HTML::HtmlFilter
+                # ...
+            
+                def can_read(file)
+                  file.get_mime_type == 'application/x-ugh'
+                end
+            
+                # ...
+              end
+            ```
+:wxHtmlFilter.ReadFile:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFilter < Wx::HTML::HtmlFilter
+                # ...
+            
+                def read_file(file)
+                  '<html><body><img src="' + file.get_location + '"></body></html>'
+                end
+            
+                # ...
+              end
+            ```
+:wxHtmlWindow.SetPage:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              htmlwin.set_page('<html><body>Hello, world!</body></html>')
+            ```

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

@@ -0,0 +1,11 @@
+---
+:wxPGEditor:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```
+              editor = Wx::PG::PropertyGrid.register_editor_class(MyEditorClass.new)
+            ```

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

@@ -0,0 +1,78 @@
+---
+:wxPGMultiButton:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /public.*wxPGTextCtrlEditor/
+          :replace: |
+            
+            ```ruby
+              class WxSampleMultiButtonEditor < Wx::PG::PGTextCtrlEditor
+            
+                def initialize
+                  super
+                end
+            
+                def create_controls(propGrid, property, pos, sz)
+                  # Create and populate buttons-subwindow
+                  buttons = Wx::PG::PGMultiButton.new(propGrid, sz)
+              
+                  # Add two regular buttons
+                  buttons.add('...')
+                  buttons.add('A')
+                  # Add a bitmap button
+                  buttons.add(Wx::ArtProvider::get_bitmap(Wx::ART_FOLDER))
+              
+                  # Create the 'primary' editor control (textctrl in this case)
+                  primary, _ = super(propGrid, property, pos, buttons.primary_size)
+              
+                  # Finally, move buttons-subwindow to correct position and make sure
+                  # returned Wx::PG::PGWindowList contains our custom button list.
+                  buttons.finalize(propGrid, pos)
+              
+                  [primary, buttons]
+                end
+            
+                def on_event(propGrid, property, ctrl, event)
+                  if event.event_type == Wx::EVT_BUTTON
+                    buttons = propGrid.get_editor_control_secondary
+                
+                    if event.id == buttons.button_id(0)
+                
+                      # Do something when the first button is pressed
+                      Wx::log_info('First button pressed')
+                      return false # Return false since value did not change
+                    end
+                    if event.id == buttons.get_button_id(1)
+                
+                      # Do something when the second button is pressed
+                      Wx.message_box('Second button pressed')
+                      return false # Return false since value did not change
+                    end
+                    if event.id == buttons.button_id(2)
+                      # Do something when the third button is pressed
+                      Wx.message_box('Third button pressed')
+                      return false # Return false since value did not change
+                    end
+                  end
+                  super(propGrid, property, ctrl, event)
+                end
+            
+              end # class WxSampleMultiButtonEditor
+            ```
+        - :pattern: !ruby/regexp /Register.*editor.*class/
+          :replace: |
+            
+            ```ruby
+              # Register editor class - needs only to be called once
+              @sampleMultiButtonEditor =
+                Wx::PG::PropertyGrid.register_editor_class(WxSampleMultiButtonEditor.new)
+            
+              # ...
+            
+              # Insert the property that will have multiple buttons
+              propGrid.append(Wx::PG::LongStringProperty.new("MultipleButtons", Wx::PG::PG_LABEL))
+            
+              # Change property to use editor created in the previous code segment
+              propGrid.set_property_editor("MultipleButtons", @sampleMultiButtonEditor)            
+            ```

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

@@ -0,0 +1,244 @@
+---
+:wxCursorProperty.OnCustomPaint.paintdata:
+  :brief:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxImageFileProperty.OnCustomPaint.paintdata:
+  :brief:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxSystemColourProperty.OnCustomPaint.paintdata:
+  :brief:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxDirProperty.DoGetValidator:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /SetPropertyValidator/
+          :subst: '#set_property_validator'
+        - :pattern: !ruby/regexp /In.*most.*situations,.*first.*macro\)\:/
+          :subst: 'In most situations, code like this should work well:'
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyPropertyClass < Wx::PG::DirProperty
+  
+  
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+                
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxFileProperty.DoGetValidator:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /SetPropertyValidator/
+          :subst: '#set_property_validator'
+        - :pattern: !ruby/regexp /In.*most.*situations,.*first.*macro\)\:/
+          :subst: 'In most situations, code like this should work well:'
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyPropertyClass < Wx::PG::FileProperty
+            
+            
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+            
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxFloatProperty.DoGetValidator:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /SetPropertyValidator/
+          :subst: '#set_property_validator'
+        - :pattern: !ruby/regexp /In.*most.*situations,.*first.*macro\)\:/
+          :subst: 'In most situations, code like this should work well:'
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyPropertyClass < Wx::PG::FloatProperty
+            
+            
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+            
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxIntProperty.DoGetValidator:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /SetPropertyValidator/
+          :subst: '#set_property_validator'
+        - :pattern: !ruby/regexp /In.*most.*situations,.*first.*macro\)\:/
+          :subst: 'In most situations, code like this should work well:'
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyPropertyClass < Wx::PG::IntProperty
+            
+            
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+            
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxUIntProperty.DoGetValidator:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /SetPropertyValidator/
+          :subst: '#set_property_validator'
+        - :pattern: !ruby/regexp /In.*most.*situations,.*first.*macro\)\:/
+          :subst: 'In most situations, code like this should work well:'
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyPropertyClass < Wx::PG::UIntProperty
+            
+            
+                class << self
+                  def validator
+                    @validator ||= MyValidator.new(...)
+                  end
+                end
+            
+                # ...
+            
+                def do_get_validator
+                  MyPropertyClass.validator
+                end
+            
+                # ...
+            
+              end
+            ```
+:wxFlagsProperty.ChildChanged:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyProperty < Wx::PG::FlagsProperty
+            
+                def child_changed(thisValue, childIndex, childValue)
+                  # Acquire reference to actual type of data stored in variant
+                  flags = thisValue.object;
+                  case childIndex
+                    when 0
+                      flags.sub_prop1 = childValue.to_i
+                    when 1
+                      flags.sub_prop2 = childValue.to_s
+                    # ...
+                  end
+                  # return altered data
+                  Wx::Variant.new(flags)
+                end
+            
+              end
+            ```
+:wxFontProperty.ChildChanged:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class WxFontDataProperty < Wx::PG::FontProperty
+            
+                def child_changed(thisValue, childIndex, childValue)
+                  fontData = thisValue.object
+                  fontData.initial_font = fontData.chosen_font
+                  
+                  case childIndex
+                    when 6
+                      col = childValue.colour
+                      fontData.colour = col
+                    else
+                      # Transfer from subset to superset.
+                      font = fontData.chosen_font
+                      variant = Wx::Variant.new(font)
+                      variant = super(variant, childIndex, childValue)
+                      font = variant.font
+                      fontData.chosen_font = font
+                  end
+                  
+                  Wx::Variant.new(fontData)
+                end
+            
+              end
+            ```
+:wxIntProperty:
+  :detail:
+    :replace:
+      :text: |
+        
+        <b>Supported special attributes:</b>
+        - {Wx::PG::PG_ATTR_MIN}, {Wx::PG::PG_ATTR_MAX}, {Wx::PG::PG_ATTR_SPINCTRL_STEP}, {Wx::PG::PG_ATTR_SPINCTRL_WRAP}, {Wx::PG::PG_ATTR_SPINCTRL_MOTION}: like in {Wx::PG::NumericProperty}.