wxruby3 0.9.0.pre.beta.10 → 0.9.0.pre.beta.13

data/lib/wx/doc/gdi_common.rb

@@ -52,24 +52,45 @@ 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
 
+    include Comparable
+
     # Returns point array (`[x, y]`)
     # @return [Array(Integer,Integer)] point as array
     def to_ary; end
 
-    # Compare point values (Wx::Point or point array). Throws exception if incompatible.
+    # Compare point values (Wx::Point or point array). Returns -1,0 or 1 to indicate if this point
+    # is smaller, equal or greater than other (comparing <code>x*y</code> with <code>other.x*other.y</code>).
+    # Returns nil if incompatible.
     # @param [Wx::Point,Array(Integer,Integer)] other
-    # @return [Boolean]
-    def ==(other)end
+    # @return [Boolean,nil]
+    def <=>(other)end
 
     # Compare points.
     # @param [Wx::Point] other
     # @return [Boolean]
     def eql?(other)end
 
+    # Returns hash for point
+    def hash; end
+
     # Return a new Wx::Point with the x and y parameters both divided by
     # parameter +num+, which should be a Numeric
     # @param [Numeric] num
@@ -97,11 +118,27 @@ module Wx
     # @param [Wx::Point,Wx::Size,Array(Integer,Integer),Numeric] arg
     # @return [Wx::Point]
     def +(arg) end
-    
+
+    # Converts point to Wx::RealPoint
+    # @return [Wx::RealPoint] Wx::RealPoint instance from point coordinates
+    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
 
+    include Comparable
+
     # Returns point array (`[x, y]`)
     # @return [Array(Float,Float)] point as array
     def to_ary; end
@@ -111,11 +148,21 @@ module Wx
     # @return [Boolean]
     def ==(other)end
 
+    # Compare point values (Wx::RealPoint or point array). Returns -1,0 or 1 to indicate if this point
+    # is smaller, equal or greater than other (comparing <code>x*y</code> with <code>other.x*other.y</code>).
+    # Returns nil if incompatible.
+    # @param [Wx::RealPoint,Array(Float,Float)] other
+    # @return [Boolean,nil]
+    def <=>(other)end
+
     # Compare points.
     # @param [Wx::RealPoint] other
     # @return [Boolean]
     def eql?(other)end
 
+    # Returns hash for point
+    def hash; end
+
     # Return a new Wx::RealPoint with the x and y parameters both divided by
     # parameter +num+, which should be a Numeric
     # @param [Numeric] num
@@ -144,6 +191,19 @@ module Wx
     # @return [Wx::RealPoint]
     def +(arg) end
 
+    # Converts real point to Wx::Point
+    # @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
@@ -152,7 +212,7 @@ module Wx
     # @return [Array(Integer,Integer,Integer,Integer)] rect as array
     def to_ary; end
 
-    # Compare area values (Wx::Rect or 4-element array). Throws exception if incompatible.
+    # Compare area values (Wx::Rect or 4-element array). Returns false if incompatible.
     # @param [Wx::Rect,Array(Integer,Integer,Integer,Integer)] other
     # @return [Boolean]
     def ==(other)end
@@ -162,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
@@ -169,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

@@ -0,0 +1,17 @@
+
+class Wx
+
+  class ScaledDC < Wx::DC
+
+    private :initialize
+
+    # Creates a Wx::ScaledDC instance for target and scale and
+    # passes the instance to the given block to draw on.
+    # @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
+
+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/global_const.rb

@@ -4,7 +4,7 @@
 module WxGlobalConstants
 
   class << self
-    def search_nested(mod, sym)
+    def search_nested(mod, sym, path = [])
       # check any nested modules and/or (enum) classes
       const_val = nil
       mod.constants.each do |c|
@@ -16,11 +16,12 @@ module WxGlobalConstants
           elsif cv.name.start_with?('Wx::') # only search Wx namespace
             # prevent const_missing being triggered here since that may lead to unexpected results
             const_val = cv.const_get(sym) if cv.constants.include?(sym)
-            const_val = search_nested(cv, sym) unless const_val
+            const_val = search_nested(cv, sym, path+[mod]) unless const_val || path.include?(cv)
           end
         when ::Module
           if cv.name.start_with?('Wx::') # only search Wx namespace
-            const_val = cv.const_get(sym) rescue nil
+            const_val = cv.const_get(sym)  if cv.constants.include?(sym)
+            const_val = search_nested(cv, sym, path+[mod]) unless const_val || path.include?(cv)
           end
         end unless mod == cv # watch out for infinite recursion
         break if const_val

data/lib/wx/version.rb

@@ -1,3 +1,3 @@
 module Wx
-  WXRUBY_VERSION    = '0.9.0-beta.10'
+  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

@@ -208,7 +208,7 @@ module WXRuby3
         # next initialize all modules without classes (keeping only those with classes)
         inc_dirs.select! do |dir|
           modreg = Spec.module_registry[dir.spec.module_name]
-          if modreg.nil? || modreg.empty?
+          if !dir.spec.initialize_at_end && (modreg.nil? || modreg.empty?)
             init = "Init_#{dir.spec.module_name}()"
             decls << "extern \"C\" void #{init};"
             init_fn << "  #{init};"
@@ -222,7 +222,7 @@ module WXRuby3
         cls_set = ::Set.new
         inc_dirs.select! do |dir|
           modreg = Spec.module_registry[dir.spec.module_name]
-          if modreg && !modreg.empty? && modreg.values.all? {|base| base.nil? || modreg.has_key?(base) }
+          if !dir.spec.initialize_at_end && modreg && !modreg.empty? && modreg.values.all? {|base| base.nil? || modreg.has_key?(base) }
             cls_set.merge modreg.keys # remember classes
             init = "Init_#{dir.spec.module_name}()"
             decls << "extern \"C\" void #{init};"
@@ -235,7 +235,7 @@ module WXRuby3
 
         # next initialize all modules with classes depending (bases AND mixins) on classes in any modules already
         # selected until there are no more modules left or none that are left depend on any selected ones
-        while dir_inx = inc_dirs.find_index { |dir| is_dir_with_fulfilled_deps?(dir, cls_set) }
+        while dir_inx = inc_dirs.find_index { |dir| !dir.spec.initialize_at_end && is_dir_with_fulfilled_deps?(dir, cls_set) }
           dir = inc_dirs[dir_inx]
           modreg = Spec.module_registry[dir.spec.module_name]
           cls_set.merge modreg.keys # remember classes
@@ -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/core/spec.rb

@@ -77,6 +77,7 @@ module WXRuby3
         @post_processors = processors || [:rename, :fixmodule, :fix_protected_access]
         @requirements = [requirements].flatten
         @type_maps = Typemap::Collection.new
+        @initialize_at_end = false
       end
 
       attr_reader :director, :package, :module_name, :name, :items, :folded_bases, :ignores, :regards, :readonly, :contracts, :event_overrides,
@@ -85,6 +86,7 @@ module WXRuby3
                   :runtime_code, :header_code, :wrapper_code, :extend_code, :init_code, :interface_code,
                   :nogen_sections, :post_processors, :requirements, :type_maps
       attr_writer :interface_file
+      attr_accessor :initialize_at_end
 
       def interface_file
         @interface_file || File.join(Config.instance.classes_path, @name + '.i')

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