wxruby3 0.9.0.pre.beta.11 → 0.9.0.pre.beta.13

data/lib/wx/doc/extra/10_art.md

@@ -0,0 +1,105 @@
+<!--
+# @markup markdown
+# @title 10. wxRuby Locating and loading art
+-->
+
+# 9. wxRuby Locating and loading art
+
+## Introduction
+
+With C++ wxWidgets applications art (icons, bitmaps, cursors, images) can be loaded in a variety 
+of ways from embedded resources (platform specific binary resources or embedded XPM files) or from
+binary datasets retrieved from some data source.  
+
+With wxRuby that is for various reasons not a viable option so we are left with the option to
+load art from files. In and of itself that option is not really too bad but for the issue of locating 
+the art files.
+Art that is part of the application's design will preferably be stored with the source code but there
+is not standard for this nor is there any standard support for locating those files from the application
+code like there is for `require`-s of other code modules.
+
+The wxRuby framework provides a convenience module `Wx::ArtLocator` to assist in that respect.
+Wx::ArtLocator aims on the one side to standardize folder structures for storing art files and on the
+other side to provide runtime support for locating those files from code.
+
+The main locator method provided is:
+
+```ruby
+  module Wx::Locator
+    def self.find_art(art_name, art_type: nil, art_path: nil, art_section: nil, bmp_type: nil)
+      # ...
+    end
+  end
+```
+
+The 'art_name' argument should provide the base name for matching art files and can be specified as either
+String or Symbol.
+
+## Storage locations
+
+Wx::ArtLocator defines a standardized directory structure that is assumed to be used for application art
+file storage.
+Working from a certain (application defined) base search path ('art_path' argument) this structure looks like this:
+
+    <art_path>
+              \art
+                  \<art_section>
+                                \<art_type>
+
+Where '<art_path>' is an application supplied search path, 'art' is the default name for Art folders (this can be overridden by an application specific name),
+'<art_section>' is an application defined id allowing sub-categorizing art and '<art_type>' is the type of art indicator 
+(which can be 'icon', 'bitmap', 'cursor', 'image').
+Art files can be located at any level in this hierarchy and all sub levels in this hierarchy are optional. 
+When locating files the art locator will test a file's existence at all levels starting with the
+deepest level working it's way up returning the absolute path of the first file found this way.
+
+So locating an art file would involve testing for the file at the following paths:
+1. \<art_path>/art/<art_section>/<art_type>/
+2. \<art_path>/art/<art_section>/
+3. \<art_path>/art/
+4. \<art_path>/
+
+The first location can be skipped by specifying `nil` for 'art_type'.
+
+## Bitmap types
+
+Based on platform and specified '<art_type>' (and optionally a specific Wx::BitmapType) art files with a specific
+range of extensions will be tested in a specific order.
+For example for locating an `:icon` (<art_type>) on platform 'WXGTK' the locator will test the preferred extension
+'.xpm' followed by any of supported extensions of all other supported bitmap types.
+For platform 'WXMSW' however the same search would test only the extensions '.ico' and '.xpm' (in that
+order).
+Specifying a specific Wx::BitmapType for a search will restrict the search to testing only the extensions supported
+for the specified Wx::BitmapType.
+
+## Search paths
+
+To prevent having to specify base search path for every location request Wx::Locator provides 2 options.
+
+When an explicit specification of a base search path ('art_path) is omitted from a location request the locator
+will determine one by using `Kernel#caller_locations` to extract the absolute path for the source file containing
+the caller's code. The result of `File.dirname(src_path)` is than used as base search path.
+If 'art_section' is also omitted the result of `File.basename(src_path, '.*')` will be used instead.
+
+This means that calling `Wx::ArtLocator.find_art` from some code in file `/some/lib/path/to/ruby/code.rb` without 
+specifying both 'art_path' and 'art_section' would result in looking for an art file with the base search path
+being `/some/lib/path/to/ruby/` and using `code` as 'art_section'.
+
+It is also possible to add 'application global' search paths with the method `Wx::ArtLocator.add_search_path`.
+Search paths added in this way will be tested after failing to find any matching art file at the initial 'art_path'
+location. The same location steps apply to these search paths as with the initial 'art_path' (see above).
+
+## Convenience methods
+
+Based on the Wx::ArtLocator implementation wxRuby additionally provides a number of convenience methods to
+easily create Icons, Bitmaps, Cursors and Images from simple ids (symbols).
+These methods mimic the ease of use of the `wxICON` and `wxBITMAP` macros used with C++ wxWidgets such that
+creating an Wx::Icon instance could be as easy as:
+
+```ruby
+    frame.icon = Wx::Icon(:sample)
+```
+
+As these methods apply the same search path 'automagic' as `Wx::ArtLocator.find_art` (see [Search paths](#Search-paths))
+this would search for an art file with base name 'sample' and an appropriate extension (like '.xpm' for the 'WXGTK' platform)
+in a location starting at the directory in which the caller's code is stored (applying the steps described above).

data/lib/wx/doc/gc_dc.rb

@@ -0,0 +1,21 @@
+
+class Wx
+
+  class GCDC < Wx::DC
+
+    private :initialize
+
+    # Creates a Wx::GCDC instance for target and
+    # passes the instance to the given block to draw on.
+    # @overload draw_on(dc)
+    #   @param [Wx::WindowDC,Wx::MemoryDC,Wx::PrinterDC] target DC to draw on
+    #   @yieldparam [Wx::GCDC] dc GCDC instance to draw on
+    #   @return [Object] result from block
+    # @overload draw_on(dc)
+    #   @param [Wx::GraphicsContext] gc GraphicsContext to draw on
+    #   @yieldparam [Wx::GCDC] dc GCDC instance to draw on
+    #   @return [Object] result from block
+    def self.draw_on(arg) end
+  end
+
+end

data/lib/wx/doc/gdi_common.rb

@@ -52,6 +52,20 @@ module Wx
     # @return [Wx::Size]
     def +(arg) end
 
+    alias :get_x :get_width
+    alias :x :get_width
+    alias :get_y :get_height
+    alias :y :get_height
+
+    # Set this size to the given size's width,height values
+    # @param [Wx::Size] sz
+    # @return [self]
+    def assign(sz) end
+
+    # Returns self.
+    # @return [self]
+    def to_size; end
+
   end
 
   class Point
@@ -110,6 +124,15 @@ module Wx
     def to_real_point; end
     alias :to_real :to_real_point
 
+    # Returns self.
+    # @return [self]
+    def to_point; end
+
+    # Set this point to the given point's x,y values
+    # @param [Wx::Point] pt
+    # @return [self]
+    def assign(pt) end
+
   end
 
   class RealPoint
@@ -172,6 +195,15 @@ module Wx
     # @return [Wx::Point] Wx::Point instance from real point coordinates
     def to_point; end
 
+    # Returns self.
+    # @return [self]
+    def to_real_point; end
+
+    # Set this point to the given point's x,y values
+    # @param [Wx::RealPoint] pt
+    # @return [self]
+    def assign(pt) end
+
   end
 
   class Rect
@@ -190,6 +222,88 @@ module Wx
     # @return [Boolean]
     def eql?(other)end
 
+    # Update this rectangle to the union with 'rect'
+    # @param [Wx::Rect] rect
+    # @return [self]
+    def union!(rect) end
+
+    # Update this rectangle to the intersection with 'rect'
+    # @param [Wx::Rect] rect
+    # @return [self]
+    def intersect!(rect) end
+
+    # @overload deflate!(dx, dy)
+    #   Decrease the rectangle size.
+    #   This method is the opposite from {inflate!}: deflate!(a, b) is equivalent to inflate!(-a, -b). Please refer to {inflate!} for full description.
+    #   @param dx [Integer]
+    #   @param dy [Integer]
+    #   @return [self]
+    # @overload deflate!(diff)
+    #   Decrease the rectangle size.
+    #   This method is the opposite from {inflate!}: deflate!(a, b) is equivalent to inflate!(-a, -b). Please refer to {inflate!} for full description.
+    #   @param diff [Array(Integer, Integer), Wx::Size]
+    #   @return [self]
+    # @overload deflate!(diff)
+    #   Decrease the rectangle size.
+    #   This method is the opposite from {inflate!}: deflate!(a, b) is equivalent to inflate!(-a, -b). Please refer to {inflate!} for full description.
+    #   @param diff [Integer]
+    #   @return [self]
+    def deflate!(*args) end
+
+    # @overload inflate!(dx, dy)
+    #   Increases the size of the rectangle.
+    #   The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2*dx and 2*dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction.
+    #   Inflating and deflating behaves "naturally". Defined more precisely, that means:
+    #   - "Real" inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)- Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).
+    #   @see #inflate
+    #   @see #deflate!
+    #   @param dx [Integer]
+    #   @param dy [Integer]
+    #   @return [self]
+    # @overload inflate!(diff)
+    #   Increases the size of the rectangle.
+    #   The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2*dx and 2*dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction.
+    #   Inflating and deflating behaves "naturally". Defined more precisely, that means:
+    #   - "Real" inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)- Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).
+    #   @see deflate
+    #   @param diff [Array(Integer, Integer), Wx::Size]
+    #   @return [self]
+    # @overload inflate!(diff)
+    #   Increases the size of the rectangle.
+    #   The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2*dx and 2*dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction.
+    #   Inflating and deflating behaves "naturally". Defined more precisely, that means:
+    #   - "Real" inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)- Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).
+    #   @see deflate
+    #   @param diff [Integer]
+    #   @return [self]
+    def inflate!(*args) end
+
+    # @overload offset(dx, dy)
+    #   Moves the rectangle by the specified offset.
+    #   If dx is positive, the rectangle is moved to the right, if dy is positive, it is moved to the bottom, otherwise it is moved to the left or top respectively.
+    #   @param dx [Integer]
+    #   @param dy [Integer]
+    #   @return [Wx::Rect]
+    # @overload offset(pt)
+    #   Moves the rectangle by the specified offset.
+    #   If dx is positive, the rectangle is moved to the right, if dy is positive, it is moved to the bottom, otherwise it is moved to the left or top respectively.
+    #   @param pt [Array(Integer, Integer), Wx::Point]
+    #   @return [Wx::Rect]
+    def offset(*args) end
+
+    # @overload offset!(dx, dy)
+    #   Moves the rectangle by the specified offset.
+    #   If dx is positive, the rectangle is moved to the right, if dy is positive, it is moved to the bottom, otherwise it is moved to the left or top respectively.
+    #   @param dx [Integer]
+    #   @param dy [Integer]
+    #   @return [self]
+    # @overload offset!(pt)
+    #   Moves the rectangle by the specified offset.
+    #   If dx is positive, the rectangle is moved to the right, if dy is positive, it is moved to the bottom, otherwise it is moved to the left or top respectively.
+    #   @param pt [Array(Integer, Integer), Wx::Point]
+    #   @return [self]
+    def offset!(*args) end
+
     alias :& :intersect
 
     alias :| :union
@@ -197,13 +311,20 @@ module Wx
     # Returns the overlap of the rectangle areas.
     # Does not check negative or zero overlap like #intersect.
     # @param [Wx::Rect] rect
+    # @return [Wx::Rect]
     def *(rect) end
 
-    # Modifies the rectangle to contain the bounding box of this rectangle and the one passed in as parameter.
+    # Returns a rectangle containing the bounding box of this rectangle and the one passed in as parameter.
     # Does not ignore empty rectangles like #union
     # @param [Wx::Rect] rect
+    # @return [Wx::Rect]
     def +(rect) end
 
+    # Set this rectangle to the given rectangle's position & size values
+    # @param [Wx::Rect] rct
+    # @return [self]
+    def assign(rct) end
+
   end
 
 end

data/lib/wx/doc/graphics_context.rb

@@ -0,0 +1,42 @@
+
+class Wx::GraphicsContext
+
+  # @overload self.draw_on(window)
+  #   Creates a {Wx::GraphicsContext} from a {Wx::Window} and passes that object to the given block.
+  #   Deletes the gc object after the block returns.
+  #   @see Wx::GraphicsRenderer#create_context
+  #   @param window [Wx::Window]
+  #   @return [Wx::GraphicsContext]
+  # @overload self.draw_on(windowDC)
+  #   Creates a {Wx::GraphicsContext} from a {Wx::WindowDC} and passes that object to the given block.
+  #   Deletes the gc object after the block returns.
+  #   @see Wx::GraphicsRenderer#create_context
+  #   @param windowDC [Wx::WindowDC]
+  #   @return [Wx::GraphicsContext]
+  # @overload self.draw_on(memoryDC)
+  #   Creates a {Wx::GraphicsContext} from a {Wx::MemoryDC} and passes that object to the given block.
+  #   Deletes the gc object after the block returns.
+  #   @see Wx::GraphicsRenderer#create_context
+  #   @param memoryDC [Wx::MemoryDC]
+  #   @return [Wx::GraphicsContext]
+  # @overload self.draw_on(printerDC)
+  #   Creates a {Wx::GraphicsContext} from a {Wx::PrinterDC} and passes that object to the given block.
+  #   Deletes the gc object after the block returns.
+  #   Under GTK+, this will only work when using the GtkPrint printing backend which is available since GTK+ 2.10.
+  #   @see Wx::GraphicsRenderer#create_context
+  #   @see  Printing Under Unix (GTK+)
+  #   @param printerDC [Wx::PrinterDC]
+  #   @return [Wx::GraphicsContext]
+  # @overload self.draw_on(image)
+  #   Creates a {Wx::GraphicsContext} associated with a {Wx::Image} and passes that object to the given block.
+  #   Deletes the gc object after the block returns.
+  #   The image specifies the size of the context as well as whether alpha is supported (if {Wx::Image#has_alpha}) or not and the initial contents of the context. The image object must have a life time greater than that of the new context as the context copies its contents back to the image when it is destroyed.
+  #   @param image [Wx::Image]
+  #   @return [Wx::GraphicsContext]
+  # @overload self.draw_on()
+  #   Create a lightweight context that can be used only for measuring text and passes that object to the given block.
+  #   Deletes the gc object after the block returns.
+  #   @return [Wx::GraphicsContext]
+  def self.draw_on(*args) end
+
+end

data/lib/wx/doc/icon.rb

@@ -0,0 +1,18 @@
+
+class Wx::Icon
+
+  # Searches for an art file with basename 'name' and creates an Icon if found.
+  # Raises an ArgumentError if not found.
+  # Wx::ArtLocator::find_art is used to look up the art file using ::Kernel#caller_locations to
+  # determine the values for the 'art_path' and 'art_owner' arguments ('art_path' is set to the
+  # absolute path to the folder holding the caller's code and 'art_owner' to the basename of the
+  # caller's source file). The 'art_type' argument is set to <code>:icon</code>.
+  # @param [String,Symbol] name base name of art file
+  # @param [Wx::BitmapType,nil] bmp_type bitmap type for art file (nil means any supported type)
+  # @param [Integer] desired_width
+  # @param [Integer] desired_height
+  # @return [Wx::Icon]
+  # @see Wx::ArtLocator::find_art
+  def self.Icon(name, bmp_type = nil, desired_width=-1, desired_height=-1); end
+
+end

data/lib/wx/doc/id_helper.rb

@@ -0,0 +1,25 @@
+
+module Wx
+
+  # Mixin module to provide convenience method for defining Windows/Control ids.
+  # @example Define an ID module
+  #   module MyIDS
+  #     include Wx::IDHelper
+  #     # by default the offset for the next id is Wx::ID_HIGHEST which makes 'Wx::ID_HIGHEST+1'
+  #     # the first id value returned.
+  #     MY_FIRST_ID = self.next_id
+  #     MY_SECOND_ID = self.next_id   # MY_SECOND_ID will have value Wx::ID_HIGHEST+2
+  #
+  #     # optionally a user defined offset can be specified like this:
+  #     MY_OTHER_ID = self.next_id(MY_FIRST_ID+1000)  # MY_OTHER_ID will have value MY_FIRST_ID+1001
+  #     MY_OTHER_ID2 = self.next_id                   # MY_OTHER_ID2 will have value MY_FIRST_ID+1002
+  #   end
+  #
+  module IDHelper
+
+    # Provides the singleton method #next_id to the including module.
+    def self.included(base) end
+
+  end
+
+end

data/lib/wx/doc/image.rb

@@ -0,0 +1,33 @@
+
+module Wx
+
+  class Image
+
+    # Returns an array of BitmapTypes identifying the available image handlers.
+    # @return [Array<Wx::BitmapType>]
+    def self.handlers; end
+
+    # Returns an array with the supported file extensions (as 'bmp') of the available image handlers.
+    # @return [Array<String>]
+    def self.extensions; end
+
+    # returns a Hash with all supported extensions per available BitmapType
+    # @return [Hash]
+    def self.handler_extensions; end
+
+    # Searches for an art file with basename 'name' and creates an Image if found.
+    # Raises an ArgumentError if not found.
+    # Wx::ArtLocator::find_art is used to look up the art file using ::Kernel#caller_locations to
+    # determine the values for the 'art_path' and 'art_owner' arguments ('art_path' is set to the
+    # absolute path to the folder holding the caller's code and 'art_owner' to the basename of the
+    # caller's source file). The 'art_type' argument is set to <code>:icon</code>.
+    # @param [String,Symbol] name base name of art file
+    # @param [Wx::BitmapType,nil] bmp_type bitmap type for art file (nil means any supported type)
+    # @param [Integer] index  Index of the image to load in the case that the image file contains multiple images. This is only used by GIF, ICO and TIFF handlers. The default value (-1) means "choose the default image" and is interpreted as the first image (index=0) by the GIF and TIFF handler and as the largest and most colourful one by the ICO handler.
+    # @return [Wx::Image]
+    # @see Wx::ArtLocator::find_art
+    def self.Image(name, bmp_type = nil, index=-1); end
+
+  end
+
+end

data/lib/wx/doc/region_iterator.rb

@@ -0,0 +1,31 @@
+
+class Wx::RegionIterator
+
+  # Creates a Wx::RegionIterator and passes that to the given block.
+  # Removes the iterator after the block finishes.
+  # @param [Wx::Region] region
+  # @yieldparam [Wx::RegionIterator] region_it
+  def self.for_region(region)  end
+
+  # Creates a Wx::RegionIterator and iterates each rectangle in the region executing the given block
+  # for each iteration passing the region iterator.
+  # @param [Wx::Region] region
+  # @yieldparam [Wx::RegionIterator] region_it
+  def self.iterate(region) end
+
+  alias :have_rects? :have_rects
+
+  # Moves to the next rectangle of the iterated region.
+  # @return [void]
+  def next_rect; end
+
+  # If a block is given the given block is called for each rectangle in the region passing the rectangle.
+  # If no block is given an Enumerator is returned.
+  # @overload each(&block)
+  #   @yieldparam [Wx::Rect] rect
+  #   @return [Object]
+  # @overload each()
+  #   @return [Enumerator]
+  def each; end
+
+end

data/lib/wx/doc/scaled_dc.rb

@@ -10,6 +10,7 @@ class Wx
     # @param [Wx::DC] target DC to draw on (scaled)
     # @param [Float] scale scale factor
     # @yieldparam [Wx::ScaledDC] dc scaled dc to draw on
+    # @return [Object] result from block
     def self.draw_on(target, scale) end
   end
 

data/lib/wx/doc/window.rb

@@ -0,0 +1,18 @@
+
+class Wx::Window
+
+  # Creates an appropriate (temporary) DC to paint on and
+  # passes that to the given block. Deletes the DC when the block returns.
+  # Creates a Wx::PaintDC when called from an evt_paint handler and a
+  # Wx::ClientDC otherwise.
+  # @yieldparam [Wx::PaintDC,Wx::ClientDC] dc dc to paint on
+  # @return [Object] result from block
+  def paint; end
+
+  # Similar to #paint but this time creates a Wx::AutoBufferedPaintDC when called
+  # from an evt_paint handler and a Wx::ClientDC otherwise.
+  # @yieldparam [Wx::AutoBufferedPaintDC,Wx::ClientDC] dc dc to paint on
+  # @return [Object] result from block
+  def paint_buffered; end
+
+end

data/lib/wx/version.rb

@@ -1,3 +1,3 @@
 module Wx
-  WXRUBY_VERSION    = '0.9.0-beta.11'
+  WXRUBY_VERSION    = '0.9.0-beta.13'
 end

data/lib/wx/wxruby/cmd/sampler.rb

@@ -15,24 +15,6 @@ module WxRuby
         "    sampler [help]|[copy DEST]\tRun wxRuby3 Sampler application (or copy samples)."
       end
 
-      def self.parse_args(args)
-        opts = OptionParser.new
-        opts.banner = "Usage: wxruby [global options] sampler [-h]|[-s PATH]\n"
-        opts.separator ''
-        opts.on('-s PATH', '--save=PATH',
-                'Save wxRuby samples under PATH.') do |v|
-          OPTIONS[:save_path] = v.to_s
-        end
-        opts.on('-h', '--help',
-                'Show this message.') do |v|
-          puts opts
-          puts
-          exit(0)
-        end
-        opts.raise_unknown = false
-        opts.parse!(args)
-      end
-
       def self.run(argv)
         if argv == :describe
           description
@@ -47,15 +29,15 @@ module WxRuby
               puts '    Starts the sampler application if called without arguments.'
               puts '    Otherwise shows this help for argument "help" or copies the included wxRuby'
               puts '    sample folders under the directory indicated by DEST for argument "copy DEST".'
-              puts '    The directory indicated  by DEST *must* already exist.'
+              puts '    The directory indicated by DEST *must* already exist.'
               puts
             elsif arg == 'copy'
               unless File.directory?(dest = argv.shift)
-                STDERR.puts "ERROR: Invalid destination folder #{DEST}"
+                STDERR.puts "ERROR: Invalid destination folder #{dest}"
                 exit(1)
               end
               Dir[File.join(WxRuby::ROOT, 'samples', '*')].each do |fp|
-                FileUtils.cp_r(fp, dest, verbose: true, noop: true)
+                FileUtils.cp_r(fp, dest, verbose: true)
               end
             end
           end

data/rakelib/lib/config.rb

@@ -145,11 +145,11 @@ module WXRuby3
     end
     private :do_run
 
-    def make_ruby_cmd(*cmd)
+    def make_ruby_cmd(*cmd, verbose: true)
       [
         FileUtils::RUBY,
         '-I', rb_lib_path,
-        (verbose? ? '-v' : nil),
+        (verbose && verbose? ? '-v' : nil),
         *cmd.flatten
       ].compact
     end
@@ -159,8 +159,8 @@ module WXRuby3
       do_run(*cmd.flatten)
     end
 
-    def run(*cmd, capture: nil)
-      do_run(*make_ruby_cmd(cmd), capture: capture)
+    def run(*cmd, capture: nil, verbose: true)
+      do_run(*make_ruby_cmd(cmd, verbose: verbose), capture: capture)
     end
 
     def debug_command(*args)

data/rakelib/lib/core/package.rb

@@ -389,7 +389,7 @@ module WXRuby3
 
       def generate_event_types(fout, item, evts_handled)
         fout.puts "  # from #{item.name}"
-        item.event_types.each do |evt_hnd, evt_type, evt_arity, evt_klass|
+        item.event_types.each do |evt_hnd, evt_type, evt_arity, evt_klass, _|
           evh_name = evt_hnd.downcase
           unless evts_handled.include?(evh_name)
             evt_klass ||= item.name
@@ -463,11 +463,11 @@ module WXRuby3
       end
 
       def generate_event_doc(fdoc, item, evts_handled)
-        item.event_types.each do |evt_hnd, evt_type, evt_arity, evt_klass|
+        item.event_types.each do |evt_hnd, evt_type, evt_arity, evt_klass, evt_nodoc|
           evh_name = evt_hnd.downcase
           unless evts_handled.include?(evh_name)
             evt_klass ||= item.name
-            evh_args, evh_docstr = find_event_doc(evh_name)
+            evh_args, evh_docstr = evt_nodoc ? nil : find_event_doc(evh_name)
             fdoc.doc.puts evh_docstr if evh_docstr
             fdoc.doc.puts "Processes a {#{fullname}::#{evt_type}} event." unless /Process.*\s(event|command)/ =~ evh_docstr
             case evt_arity

data/rakelib/lib/director/art_provider.rb

@@ -69,7 +69,7 @@ module WXRuby3
           
               v_id     = WXSTR_TO_RSTR(id);
               v_client = WXSTR_TO_RSTR(client);
-              v_size = SWIG_NewPointerObj(SWIG_as_voidptr(&size), SWIGTYPE_p_wxSize, 0);
+              v_size = SWIG_NewPointerObj(new wxSize(size), SWIGTYPE_p_wxSize, 1);
               v_ret = rb_funcall(self, create_bitmap_id(), 3, v_id, v_client, v_size);
           
               if (v_ret != Qnil) 
@@ -87,7 +87,7 @@ module WXRuby3
           
               v_id     = WXSTR_TO_RSTR(id);
               v_client = WXSTR_TO_RSTR(client);
-              v_size = SWIG_NewPointerObj(SWIG_as_voidptr(&size), SWIGTYPE_p_wxSize, 0);
+              v_size = SWIG_NewPointerObj(new wxSize(size), SWIGTYPE_p_wxSize, 1);
               v_ret = rb_funcall(self, create_bitmap_bundle_id(), 3, v_id, v_client, v_size);
           
               if (v_ret != Qnil) 

data/rakelib/lib/director/busy_info.rb

@@ -13,7 +13,7 @@ module WXRuby3
         super
         spec.items << 'wxBusyInfoFlags'
         spec.disable_proxies
-        spec.gc_as_temporary 'wxBusyInfoFlags'
+        spec.gc_as_temporary 'wxBusyInfo', 'wxBusyInfoFlags'
         # again C++ type guards do not work with Ruby
         # need to Rubify this
         spec.make_abstract 'wxBusyInfo'
@@ -35,29 +35,31 @@ module WXRuby3
         spec.add_extend_code 'wxBusyInfo', <<~__HEREDOC
           static VALUE busy(const wxString& message, wxWindow *parent = NULL)
           {
+            VALUE rc = Qnil;
             VALUE rb_busyinfo = Qnil;
             wxBusyInfo *p_busyinfo = 0 ;
             if (rb_block_given_p())
             {
               wxBusyInfo disabler(message,parent);
               p_busyinfo = &disabler;
-              rb_busyinfo = SWIG_NewPointerObj(SWIG_as_voidptr(p_busyinfo), SWIGTYPE_p_wxBusyInfo, 0 |  0 );
-              return rb_yield(rb_busyinfo);
+              rb_busyinfo = SWIG_NewPointerObj(SWIG_as_voidptr(p_busyinfo), SWIGTYPE_p_wxBusyInfo, 0);
+              rc = rb_yield(rb_busyinfo);
             }
-            return Qnil;
+            return rc;
           }
           static VALUE busy(const wxBusyInfoFlags &flags)
           {
+            VALUE rc = Qnil;
             VALUE rb_busyinfo = Qnil;
             wxBusyInfo *p_busyinfo = 0 ;
             if (rb_block_given_p())
             {
               wxBusyInfo disabler(flags);
               p_busyinfo = &disabler;
-              rb_busyinfo = SWIG_NewPointerObj(SWIG_as_voidptr(p_busyinfo), SWIGTYPE_p_wxBusyInfo, 0 |  0 );
-              return rb_yield(rb_busyinfo);
+              rb_busyinfo = SWIG_NewPointerObj(SWIG_as_voidptr(p_busyinfo), SWIGTYPE_p_wxBusyInfo, 0);
+              rc = rb_yield(rb_busyinfo);
             }
-            return Qnil;
+            return rc;
           }
           __HEREDOC
         spec.map 'wxBusyInfoFlags &' => 'Wx::BusyInfoFlags' do

data/rakelib/lib/director/clipboard.rb

@@ -13,7 +13,7 @@ module WXRuby3
 
       def setup
         super
-        spec.gc_never
+        spec.gc_as_temporary # don't even track Clipboard objects
         # there is no need or support for clipboard derivatives
         # not least because wxRuby only ever allows a single global clipboard
         spec.disable_proxies

data/rakelib/lib/director/colour_picker_ctrl.rb

@@ -13,6 +13,7 @@ module WXRuby3
 
       def setup
         super
+        spec.add_swig_code '%feature("notabstract") wxColourPickerCtrl;'
         spec.do_not_generate(:variables, :defines, :enums, :functions) # with ColourPickerEvent
       end
     end # class ColourPickerCtrl