wxruby3 0.9.0.pre.rc.2 → 0.9.0.pre.rc.3

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

@@ -0,0 +1,42 @@
+---
+:wxTextEntry.GetInsertionPoint:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              def get_current_char(txt_ctrl)
+                 pos = txt_ctrl.get_insertion_point
+                 return '' if pos == txt_ctrl.get_last_position
+              
+                 txt_ctrl.get_range(pos, pos + 1)
+              end
+            ```
+:wxTextCompleterSimple:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyTextCompleter < Wx::TextCompleterSimple
+            
+                def get_completions(prefix)
+                  firstWord = prefix.split(' ').shift
+                  if firstWord == 'white'
+                    ['white pawn', 'white rook']
+                  elsif firstWord == 'black'
+                    ['black king', 'black queen']
+                  else
+                    ['white', 'black']
+                  end
+                end
+            
+              end
+              ...
+              text_ctrl = ...
+              text_ctrl.auto_complete(MyTextCompleter.new)
+            ```

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

@@ -0,0 +1,17 @@
+---
+:wxTextEntryDialog.SetTextValidator:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx::TextEntryDialog(self, ...) do |dlg|
+                dlg.set_text_validator(Wx::FILTER_ALPHA)
+                if dlg.show_modal == Wx::ID_OK
+                   # We can be certain that this string contains letters only.
+                   value = dlg.get_value
+                end
+              end
+            ```

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

@@ -0,0 +1,28 @@
+---
+:wxTimerEvent:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFrame < Wx::Frame
+
+                def initialize
+                  super(nil)
+                  @timer = Wx::Timer.new(self, TIMER_ID)
+            
+                  evt_timer(TIMER_ID, :on_timer)
+            
+                  @timer.start(1000)    # 1 second interval
+                end
+                 
+                ...
+                 
+                def on_timer(event)
+                  # do whatever you want to do every second here
+                end
+              
+              end
+            ```

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

@@ -0,0 +1,35 @@
+---
+:wxToolBar.SetToolBitmapSize:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              toolbar.set_tool_bitmap_size(from_dip(Wx::Size.new(32, 32)))
+              toolbar.add_tool(Wx::ID_NEW, 'New', Wx::BitmapBundle.from_XXX(...))
+              ...
+              toolbar.realize
+            ```
+:wxToolBar:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /0\);/
+          :replace: |
+            
+            ```ruby
+              Wx::SystemOptions.set_option('msw.remap', 0)
+            ```
+        - :pattern: !ruby/regexp /2\);/
+          :replace: |
+            
+            ```ruby
+              Wx::SystemOptions.set_option('msw.remap', 2)
+            ```
+        - :pattern: !ruby/regexp /wxTheApp/
+          :replace: ''
+      :para:
+        - :pattern: !ruby/regexp /But\s+only\s+use.*true\s+colour:/
+          :subst: ''

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

@@ -0,0 +1,23 @@
+---
+:wxTopLevelWindow.MSWGetSystemMenu:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              if Wx::PLATFORM == 'WXMSW'
+            ```
+:wxTopLevelWindow.UseNativeDecorations:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              frame = MyFrame.new                   # use default ctor  
+              frame.use_native_decorations(false)   # change from default "true"
+              frame.create(parent, title, ...)      # really create the frame
+            ```

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

@@ -0,0 +1,12 @@
+---
+:wxValidator.SetWindow:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              Wx::TextCtrl.new(self, Wx::ID_ANY, '', Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE, 0,
+                               Wx::TextValidator.new(Wx::FILTER_ALPHA))
+            ```

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

@@ -0,0 +1,29 @@
+---
+:wxVariant:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+
+            A variant's value can be changed at run time, possibly to a different type of value.
+            In wxRuby Wx::Variant is the only available Wx variant class (unlike in C++) and almost exclusively for
+            use in combination with the property grid classes (see the {Wx::PG} module).
+
+            By default Wx::Variant can store values of type bool, {Integer}, {Float}, {String}, {Time} (or {Date} / {DateTime}), {Array} of {String}, 
+            {Array} of {Wx::Variant}, {Wx::Font}, {Wx::Colour} and {Wx::ColourPropertyValue}.
+            In addition Wx::Variant can store any Ruby {Object}.
+            
+            An optional name member is associated with a Wx::Variant.
+            
+            In wxRuby Wx::Variant also provides the standard conversion methods #to_i, #to_s and #to_f for supported
+            value types. In case of incompatible value types these methods will raise a {TypeError} exception.
+:wxVariant.GetType:
+  :detail:
+    :post:
+      - :pattern: !ruby/regexp /\-\s+\"void\*\"$/
+        :subst: ''
+      - :pattern: !ruby/regexp /\Z/
+        :subst: |
+          
+          If the variant contains an arbitrary Ruby {Object}, the value type returned is the result of `variant.get_object.class.name`.

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

@@ -0,0 +1,249 @@
+---
+:wxWindow.SetScrollbar:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              set_scrollbar(Wx::VERTICAL, 0, 16, 50)
+            ```
+:wxWindow.FromDIP:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              bmp = Wx::Bitmap.new(from_dip(Wx::Size.new(32, 32)))
+            ```
+:wxWindow.ToDIP:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              pt = Wx::Point.new(to_dip(get_position))
+              size = Wx::Size.new(to_dip(get_size))
+            ```
+:wxWindow.SetMaxClientSize:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              set_max_size(client_to_window_size(size))
+            ```
+:wxWindow.SetMinClientSize:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              set_min_size(client_to_window_size(size))
+            ```
+:wxWindow.Move:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              set_size(x, y, Wx::DEFAULT_COORD, Wx::DEFAULT_COORD, Wx::SIZE_USE_EXISTING)
+            ```
+:wxWindow.ConvertDialogToPixels:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /A\s+convenience\s+macro\s+is\s+defined:/
+          :subst: ''
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: ''
+:wxWindow.SetBackgroundStyle:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyWidget < Wx::Window
+                def initialize(parent, ...)
+                  super() # Use default ctor here!
+                   # Do this first:
+                   set_background_style(Wx::BG_STYLE_TRANSPARENT)
+            
+                   # And really create the window afterwards:
+                   create(parent, ...)
+                end
+              end
+            ```
+:wxWindow.HandleWindowEvent:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              get_event_handler.safely_process_event(event)
+            ```
+:wxWindow.ProcessWindowEvent:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              get_event_handler.process_event(event)
+            ```
+:wxWindow.PushEventHandler:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              W.push_event_handler(A)
+              W.push_event_handler(B)
+            ```
+:wxWindow.Enable:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              w = MyWindow.new # Note: default ctor is used here.
+              w.enable(false)
+              w.create(parent, ... all the usual non-default ctor arguments ...)
+            ```
+:wxWindow.EnableTouchEvents:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              enable_touch_events(Wx::TOUCH_ZOOM_GESTURE | Wx::TOUCH_ROTATE_GESTURE)
+            ```
+:wxWindow.DoUpdateWindowUI:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              # do the window-specific processing after processing the update event
+              def Wx::TopLevelWindow.do_update_window_ui(event)
+                if event.get_set_enabled
+                  enable(event.get_enabled)
+                end
+              
+                if event.get_set_text
+                  if event.get_text != get_title
+                    set_title(event.get_text)
+                  end
+                end
+              end
+            ```
+:wxWindow.UpdateWindowUI:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyWindow
+                ...
+                def on_internal_idle
+                  update_window_ui(Wx::UPDATE_UI_FROMIDLE) if Wx::UpdateUIEvent.can_update(self)
+                end
+                ...
+              end
+            ```
+:wxWindow.Create:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxPanel/
+          :replace: |
+            
+            ```ruby
+              panel = Wx::Panel.new   # Note: default constructor used.
+              panel.hide  # Can be called before actually creating it.
+              panel.create(parent, Wx::ID_ANY, ...)   # Won't be shown yet.
+              ... create all the panel children ...
+              panel.show  # Now everything will be shown at once.
+            ```
+        - :pattern: !ruby/regexp /MyCreateWindowObjectFunction/
+          :replace: |
+            
+            ```ruby
+              # Suppose we have this function (which would typically be in a
+              # different file from the rest of the code).
+              def my_create_window_object_function
+                 MyCustomClassDerivingFromWindow.new
+              end
+              
+              # Then we can create a window of MyCustomClassDerivingFromWindow
+              # class without really knowing about this type, as we would have
+              # to do if we wanted to use the non-default constructor, like this:
+              
+              # First create the C++ object using the factory function.
+              window = my_create_window_object_function
+              
+              # And now create the underlying window.
+              #
+              # This should call the base Wx::Window#create.
+              # In C++ (wxWidgets) this method is not virtual and cannot be overloaded
+              # so the derived class can't customize this part.
+              # In wxRuby however this method can be overloaded as long as the following
+              # is kept in mind:
+              # 1. the overloaded version will **NOT** be called when using a non-default
+              #    constructor (Create will than be called from C++ which will always be 
+              #    the base Wx::Window version);
+              # 2. when calling the overloaded version from Ruby understand that the window
+              #    will not actually be created until after the `super` version has been called.
+              # In general it's best not to overload this method but to define a different method
+              # if a custom initializer is needed.
+              window.create(parent, Wx::ID_ANY, ...)
+            ```
+:wxWindow.MSWDisableComposited:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              class MyFrame < Wx::Frame
+                def initialize(...)
+                  ...
+                  p = Wx::Panel.new(self)
+                  if Wx::PLATFORM == 'WXMSW'
+                    p.msw_disable_composited
+                  end
+              
+                  # Using Wx::ClientDC will work now with this panel in wxMSW --
+                  # although it still won't with wxOSX nor wxGTK under Wayland.            
+                end
+                ...            
+              end
+            ```

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

@@ -0,0 +1,14 @@
+---
+:wxWizardPageSimple.Chain:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              firstPage = FirstPage.new # derived from Wx::WizardPageSimple
+              firstPage.chain(SecondPage.new)
+                         .chain(ThirdPage.new)
+                         .chain(LastPage.new)
+            ```

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

@@ -0,0 +1,7 @@
+---
+:wxXmlNode.GetNodeContent:
+  :detail:
+    :pre:
+      :para:
+        - :pattern: !ruby/regexp /tagnametagcontent\/tagname/
+          :subst: '<tagname>tagcontent</tagname>'

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

@@ -0,0 +1,27 @@
+---
+:wxXmlResource.Load:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              if !Wx::XmlResource.get.load('rc/*.xrc')
+                Wx.log_error("Couldn't load resources!")
+              end
+            ```
+:wxXmlResource.LoadDialog:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+              dlg = MyDialog.new
+              Wx::XmlResource.get.load_dialog_subclass(dlg, main_frame, 'my_dialog')
+              dlg.show_modal
+            
+              dlg.destroy
+            ```

data/rakelib/lib/generate/doc.rb

@@ -277,6 +277,7 @@ module WXRuby3
 
       def _ident_str_to_doc(s, ref_scope = nil)
         return s if no_idents?
+        return s if %w[wxRuby wxMSW wxOSX wxGTK wxX11].any? { |w| s.start_with?(w) }
         nmlist = s.split('::')
         nm_str = nmlist.shift.to_s
         constnm = rb_wx_name(nm_str)
@@ -403,7 +404,7 @@ module WXRuby3
         itm_text = node_to_doc(node)
         # fix possible unwanted leading spaces resulting in verbatim blocks
         itm_text = itm_text.split("\n").collect {|s|s.lstrip}.join("\n") if itm_text.index("\n")
-        "- #{itm_text}"
+        "\n- #{itm_text}"
       end
 
       def node_to_doc(xmlnode)
@@ -589,6 +590,39 @@ module WXRuby3
         DocGenerator.constants_xref_db
       end
 
+      def type_to_doc(ctype_decl)
+        return ctype_decl if ctype_decl == 'void'
+        ctype = Typemap.strip_type_decl(ctype_decl)
+        nmlist = ctype.split('::')
+        nm_str = nmlist.shift.to_s
+        constnm = rb_wx_name(nm_str)
+        if nmlist.empty?  # unscoped id?
+          if DocGenerator.constants_xref_db.has_key?(constnm)
+            "#{DocGenerator.constants_xref_db[constnm]['mod']}::#{constnm}"
+          elsif DocGenerator.constants_xref_db.has_key?(rb_constant_name(nm_str))
+            "Wx::#{rb_constant_name(nm_str)}"
+          elsif DocGenerator.constants_xref_db.has_key?(rb_constant_name(nm_str, false))
+            "Wx::#{rb_constant_name(nm_str, false)}"
+          else
+            Typemap.wx_type_to_rb(ctype)
+          end
+        else
+          itmnm = nmlist.shift.to_s
+          if DocGenerator.constants_xref_db.has_key?(constnm)
+            constnm = "#{DocGenerator.constants_xref_db[constnm]['mod']}::#{constnm}"
+          elsif DocGenerator.constants_xref_db.has_key?(rb_constant_name(nm_str))
+            cnm = rb_constant_name(nm_str)
+            constnm = "#{DocGenerator.constants_xref_db[cnm]['mod']}::#{cnm}"
+          elsif DocGenerator.constants_xref_db.has_key?(rb_constant_name(nm_str, false))
+            cnm = rb_constant_name(nm_str, false)
+            constnm = "#{DocGenerator.constants_xref_db[cnm]['mod']}::#{cnm}"
+          elsif nm_str.start_with?('wx')
+            constnm = "Wx::#{constnm}"
+          end
+          "#{constnm}::#{rb_wx_name(itmnm)}"
+        end
+      end
+
     end
 
     def run

data/rakelib/lib/specs/interfaces.rb

@@ -17,6 +17,7 @@ module WXRuby3
     Director.Spec(pkg, 'wxEvtHandler')
     Director.Spec(pkg, 'wxEvents')
     Director.Spec(pkg, 'wxEventFilter')
+    Director.Spec(pkg, 'wxGUIEventLoop')
     Director.Spec(pkg, 'wxApp')
     Director.Spec(pkg, 'wxDC')
     Director.Spec(pkg, 'wxWindowDC', director: Director::DerivedDC)

data/rakelib/lib/swig_runner.rb

@@ -481,6 +481,43 @@ module WXRuby3
         end
       end
 
+      # Updates SWIG generated wrapper code for disowned allocation modules.
+      class FixDisownedAlloc < Processor
+
+        def run
+          # get the generated (class) items which have been defined to need disowned allocation
+          class_list = def_items.select { |itm| Extractor::ClassDef === itm && allocate_disowned?(itm) }
+          # setup a table with the required tracking methods for each class
+          track_table = class_list.inject({}) do |tbl, clsdef|
+            tbl[clsdef.name] = (gc_type(clsdef) == :GC_MANAGE_AS_UNTRACKED) ? '0' : 'SWIG_RubyRemoveTracking'
+            tbl
+          end
+          # create re match list for class names
+          cls_re_txt = class_list.collect { |clsdef| clsdef.name }.join('|')
+          # updating any matching alloc functions in generated SWIG sourcecode
+          # create regexp for 'initialize' wrappers (due to overloads this could be more than one per class)
+          alloc_re = /_wrap_(#{cls_re_txt})_allocate\(int\s+argc.*\)/
+          found_alloc = false
+          cpp_class = nil
+          update_source do |line|
+            if found_alloc # inside 'xxx_allocate' wrapper?
+              if line =~ /\A(\s*)return\s+vresult;/
+                # insert an override for the free method to disown the new instance
+                line = "#{$1}RDATA(vresult)->dfree = #{track_table[cpp_class]};\n#{line}"
+              elsif /\A}/ =~ line # end of wrapper function?
+                # stop matching
+                found_alloc = false
+              end
+            elsif alloc_re =~ line # are we at an 'xxx_allocate' wrapper?
+              found_alloc = true
+              cpp_class = $1
+            end
+            line
+          end
+        end
+
+      end
+
       # Updates SWIG generated wrapper code for Mixin modules.
       class FixInterfaceMixin < Processor
 

data/tests/test_art.rb

@@ -76,6 +76,15 @@ class TestArt < Test::Unit::TestCase
     end
   end
 
+  def test_image_histogram
+    img = Wx.Image(:wxruby, Wx::BitmapType::BITMAP_TYPE_JPEG)
+    img_hist = img.compute_histogram
+    assert(img_hist.is_a?(::Hash))
+    assert(img_hist.is_a?(Wx::Image::Histogram))
+    assert(img_hist.size > 0)
+    assert(img_hist.values.all? { |index, value| index>=0 && value>=1 })
+  end
+
   def test_art
     art = nil
     assert_nothing_raised do