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

data/lib/wx/core/id_helper.rb

@@ -0,0 +1,32 @@
+
+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
+
+    def self.included(base)
+      base.singleton_class.class_eval do
+        def next_id(offset = nil)
+          # set the offset if @next_id still unset or a user defined offset has been specified
+          @next_id = (offset || Wx::ID_HIGHEST) if @next_id.nil? || offset
+          @next_id += 1 # increment and return next id
+        end
+      end
+    end
+
+  end
+
+end

data/lib/wx/core/image.rb

@@ -1,68 +1,78 @@
 # A platform-independent image; can be manipulated more extensively than
 # Bitmap, but must be converted to a Bitmap for drawing.
-class Wx::Image
+module Wx
+  class Image
 
-  # restore the overloaded method
-  def set_rgb_data(data, *size)
-    if size.empty?
-      height = self.get_size.height
-      width = self.get_size.width
-    else
-      width, height = size
-      if Wx::Size === width
-        height = width.height
-        width = width.width
+    # restore the overloaded method
+    def set_rgb_data(data, *size)
+      if size.empty?
+        height = self.get_size.height
+        width = self.get_size.width
+      else
+        width, height = size
+        if Wx::Size === width
+          height = width.height
+          width = width.width
+        end
       end
+      set_rgb_data_with_size(data, width, height)
     end
-    set_rgb_data_with_size(data, width, height)
-  end
 
-  # alias for backward compatibility
-  alias :get_data :get_rgb_data
-  alias :set_data :set_rgb_data
-  
-  # Load the type-guessing hash from Wx::Bitmap
-  require_relative './bitmap'
-  BITMAP_TYPE_GUESS = Wx::Bitmap::BITMAP_TYPE_GUESS
+    # alias for backward compatibility
+    alias :get_data :get_rgb_data
+    alias :set_data :set_rgb_data
 
-  # Load a new image from an IO-like object that supports "read"
-  def self.read(an_io, type_or_mime, index = -1)
-    img = new
-    img.load_stream(an_io, type_or_mime, index)
-    img
-  end
+    # Load the type-guessing hash from Wx::Bitmap
+    require_relative './bitmap'
+    BITMAP_TYPE_GUESS = Wx::Bitmap::BITMAP_TYPE_GUESS
 
-  # Create a new image from Wx::Bitmap, preserving mask information
-  def self.from_bitmap(bmp)
-    bmp.convert_to_image
-  end
+    # Load a new image from an IO-like object that supports "read"
+    def self.read(an_io, type_or_mime, index = -1)
+      img = new
+      img.load_stream(an_io, type_or_mime, index)
+      img
+    end
 
-  # Ruby methods that switch class are conventionally named to_foo
-  def to_bitmap
-    Wx::Bitmap.from_image(self)
-  end
+    # Create a new image from Wx::Bitmap, preserving mask information
+    def self.from_bitmap(bmp)
+      bmp.convert_to_image
+    end
 
-  # Redefine the initialize method so it raises an exception if a
-  # non-existent file is given to the constructor; otherwise, wx Widgets
-  # just carries on with an invalid image, which may cause faults
-  # later. Also, if loading from a file, and the type is not specified,
-  # try to guess it from the filename extension
-  wx_init = self.instance_method(:initialize)
-  define_method(:initialize) do | *args |
-    if args[0].kind_of? String
-      if not File.exist?( File.expand_path(args[0]) )
-        Kernel.raise(ArgumentError, "Image file does not exist: #{args[0]}")
-      end
-      # If type not specified, try to guess it from the file extension
-      if not args[1] and file_ext = args[0][/\w+$/]
-        args[1] = BITMAP_TYPE_GUESS[file_ext.downcase]
+    # Ruby methods that switch class are conventionally named to_foo
+    def to_bitmap
+      Wx::Bitmap.from_image(self)
+    end
+
+    # Redefine the initialize method so it raises an exception if a
+    # non-existent file is given to the constructor; otherwise, wx Widgets
+    # just carries on with an invalid image, which may cause faults
+    # later. Also, if loading from a file, and the type is not specified,
+    # try to guess it from the filename extension
+    wx_init = self.instance_method(:initialize)
+    define_method(:initialize) do | *args |
+      if args[0].kind_of? String
+        if not File.exist?( File.expand_path(args[0]) )
+          Kernel.raise(ArgumentError, "Image file does not exist: #{args[0]}")
+        end
+        # If type not specified, try to guess it from the file extension
+        if not args[1] and file_ext = args[0][/\w+$/]
+          args[1] = BITMAP_TYPE_GUESS[file_ext.downcase]
+        end
       end
+      wx_init.bind(self).call(*args)
+    end
+
+    # Convert to bitmap
+    def convert_to_bitmap
+      Wx::Bitmap.from_image(self)
     end
-    wx_init.bind(self).call(*args)
   end
-  
-  # Convert to bitmap
-  def convert_to_bitmap
-    Wx::Bitmap.from_image(self)
+
+  def self.Image(name, bmp_type = nil, *rest)
+    art_path = File.dirname(caller_path = caller_locations(1).first.absolute_path)
+    art_owner = File.basename(caller_path, '.*')
+    art_file = ArtLocator.find_art(name, art_type: :image, art_path: art_path, art_section: art_owner, bmp_type: bmp_type)
+    ::Kernel.raise ArgumentError, "Cannot locate art file for #{name}:Image" unless art_file
+    Image.new(art_file, bmp_type, *rest)
   end
 end

data/lib/wx/core/point.rb

@@ -1,4 +1,7 @@
 class Wx::Point
+
+  include Comparable
+
   # More informative output when converted to string
   def to_s
     "#<Wx::Point: (#{x}, #{y})>"
@@ -16,23 +19,26 @@ class Wx::Point
   alias :get_x :x
   alias :get_y :y
 
-  # Compare point values
-  def ==(other)
-    if Wx::Point === other
+  # Correct comparison for Points - same if same x and y
+  def eql?(other)
+    if other.instance_of?(self.class)
       x == other.x and y == other.y
-    elsif Array === other && other.size == 2
-      to_ary == other
     else
-      Kernel.raise TypeError, "Cannot compare Point to #{other}"
+      false
     end
   end
 
-  # Correct comparison for Points - same if same x and y
-  def eql?(other)
+  def hash
+    to_ary.hash
+  end
+
+  def <=>(other)
     if Wx::Point === other
-      x == other.x and y == other.y
+      (x*y) <=> (other.x*other.y)
+    elsif Array === other && other.size == 2
+      (x*y) <=> (other.first.to_i*other.last.to_i)
     else
-      false
+      nil
     end
   end
 
@@ -89,4 +95,23 @@ class Wx::Point
       end
     end
   end
+
+  def to_real_point
+    Wx::RealPoint.new(self.x.to_f, self.y.to_f)
+  end
+  alias :to_real :to_real_point
+
+  def to_point
+    self
+  end
+
+  def dup
+    Wx::Point.new(self.x, self.y)
+  end
+
+  def assign(pt)
+    self.x = pt.x
+    self.y = pt.y
+    self
+  end
 end

data/lib/wx/core/real_point.rb

@@ -1,4 +1,7 @@
 class Wx::RealPoint
+
+  include Comparable
+
   # More informative output when converted to string
   def to_s
     "#<Wx::RealPoint: (#{x}, #{y})>"
@@ -16,23 +19,26 @@ class Wx::RealPoint
   alias :get_x :x
   alias :get_y :y
 
-  # Compare point values
-  def ==(other)
-    if Wx::RealPoint === other
+  # Correct comparison for RealPoints - same if same x and y
+  def eql?(other)
+    if other.instance_of?(self.class)
       x == other.x and y == other.y
-    elsif Array === other && other.size == 2
-      to_ary == other
     else
-      Kernel.raise TypeError, "Cannot compare RealPoint to #{other}"
+      false
     end
   end
 
-  # Correct comparison for RealPoints - same if same x and y
-  def eql?(other)
+  def hash
+    to_ary.hash
+  end
+
+  def <=>(other)
     if Wx::RealPoint === other
-      x == other.x and y == other.y
+      (x*y) <=> (other.x*other.y)
+    elsif Array === other && other.size == 2
+      (x*y) <=> (other.first.to_f*other.last.to_f)
     else
-      false
+      nil
     end
   end
 
@@ -89,4 +95,23 @@ class Wx::RealPoint
       end
     end
   end
+
+  def to_point
+    Wx::Point.new(self.x.to_i, self.y.to_i)
+  end
+
+  def to_real_point
+    self
+  end
+
+  def dup
+    Wx::RealPoint.new(self.x, self.y)
+  end
+
+  def assign(pt)
+    self.x = pt.x
+    self.y = pt.y
+    self
+  end
+
 end

data/lib/wx/core/rect.rb

@@ -23,12 +23,12 @@ class Wx::Rect
     elsif Array === other && other.size == 4
       to_ary == other
     else
-      Kernel.raise TypeError, "Cannot compare Rect to #{other}"
+      false
     end
   end
 
   def eql?(other)
-    if Wx::Rect === other
+    if other.instance_of?(self.class)
       left == other.left and top == other.top and
         width == other.width and height == other.height
     else
@@ -36,15 +36,40 @@ class Wx::Rect
     end
   end
 
-  # make sure union and intersect are constant operations, i.e. not changing self
-  wx_union = instance_method :union
-  define_method :union do |rect|
-    wx_union.bind(Wx::Rect.new(*self.to_ary)).call(rect)
+  # provide both constant and non-constant versions of union/intersect/inflate/deflate/offset
+
+  # first alias the wrapped (non-constant) versions with correct names
+  alias :union! :union
+  alias :intersect! :intersect
+  alias :inflate! :inflate
+  alias :deflate! :deflate
+
+  # redefine offset as offset! returning self
+  wx_offset = instance_method :offset
+  define_method :offset! do |*args|
+    wx_offset.bind(self).call(*args)
+    self
+  end
+
+  # next provide new constant versions
+  def offset(*args)
+    self.dup.offset!(*args)
+  end
+
+  def union(rect)
+    self.dup.union!(rect)
   end
 
-  wx_intersect = instance_method :intersect
-  define_method :intersect do |rect|
-    wx_intersect.bind(Wx::Rect.new(*self.to_ary)).call(rect)
+  def intersect(rect)
+    self.dup.intersect!(rect)
+  end
+
+  def inflate(*args)
+    self.dup.inflate!(*args)
+  end
+
+  def deflate(*args)
+    self.dup.deflate!(*args)
   end
 
   alias :+ :add
@@ -54,4 +79,14 @@ class Wx::Rect
 
   # More ruby-ish names
   alias :contains? :contains
+
+  def dup
+    Wx::Rect.new(self.x, self.y, self.width, self.height)
+  end
+
+  def assign(rct)
+    self.position = rct.position
+    self.size = rct.size
+    self
+  end
 end

data/lib/wx/core/region_iterator.rb

@@ -0,0 +1,37 @@
+
+class Wx::RegionIterator
+
+  alias :have_rects? :have_rects
+
+  # Ruby like enumeration
+  def each
+    if block_given?
+      while have_rects
+        yield get_rect
+        next_rect
+      end
+    else
+      # The region iterator instance cannot be allowed to exist beyond the outer
+      # Wx::RegionIterator.for_region block as it is a temporary instance that
+      # will stop to exist when the outer block finishes, so we collect the rectangles
+      # here and return an enumerator on that
+      arr = []
+      while has_rects
+        arr << get_rect
+        next_rect
+      end
+      arr.each
+    end
+  end
+
+  def self.iterate(region, &block)
+    return unless block
+    for_region(region) do |ri|
+      while ri.have_rects
+        block.call(ri)
+        ri.next_rect
+      end
+    end
+  end
+
+end

data/lib/wx/core/size.rb

@@ -1,4 +1,13 @@
 class Wx::Size
+
+  include Comparable
+
+  # provide compatibility methods
+  alias :get_x :get_width
+  alias :x :get_width
+  alias :get_y :get_height
+  alias :y :get_height
+
   # More informative output for inspect etc
   def to_s
     "#<Wx::Size: #{width}x#{height}>"
@@ -14,24 +23,28 @@ class Wx::Size
   end
 
   # Compare with another size value
-  def ==(other)
+  def <=>(other)
     if Wx::Size === other
-      width == other.width and height == other.height
+      (width*height) <=> (other.width*other.height)
     elsif Array === other and other.size == 2
-      to_ary == other
+      (width*height) <=> (other.first*other.last)
     else
-      Kernel.raise TypeError, "Cannot compare Size to #{other}"
+      nil
     end
   end
 
   def eql?(other)
-    if Wx::Size === other
+    if other.instance_of?(self.class)
       width == other.width and height == other.height
     else
       false
     end
   end
 
+  def hash
+    to_ary.hash
+  end
+
   # Return a new Wx::Size with the width and height values both divided
   # by parameter +num+, which should be a Numeric
   def /(num)
@@ -83,4 +96,18 @@ class Wx::Size
       end
     end
   end
+
+  def dup
+    Wx::Size.new(self.width, self.height)
+  end
+
+  def to_size
+    self
+  end
+
+  def assign(sz)
+    self.width = sz.width
+    self.height = sz.height
+    self
+  end
 end

data/lib/wx/core/window.rb

@@ -53,43 +53,20 @@ class Wx::Window
   def evt_paint(meth = nil, &block)
     paint_proc = acquire_handler(meth, block)
     wrapped_block = proc do | event |
-      instance_variable_set("@__painting__", true)
+      instance_variable_set('@__painting__', true)
       paint_proc.call(event)
-      remove_instance_variable("@__painting__")
+      remove_instance_variable('@__painting__')
     end
     __old_evt_paint(&wrapped_block)
   end
 
-  # Provides bufferd drawing facility to reduce flicker for complex
-  # drawing commands. Works similar to BufferedDC and BufferedPaintDC in
-  # the wxWidgets API, by doing drawing on an in-memory Bitmap, then
-  # copying the result in bulk to the screen.
-  #
-  # The method may be passed an existing Wx::Bitmap as the +buffer+,
-  # otherwise one will be created.
-  #
-  # Works like wxAutoBufferedDC in that additional buffering will only
-  # be done on platforms that do not already natively support buffering
-  # for the standard PaintDC / ClientDC - Windows, in particular.
-  def paint_buffered(buffer = nil)
-    # OS X and GTK do double-buffering natively
-    if self.double_buffered?
-      paint { | dc | yield dc }
+  # Overload the wrapper method to check for @__painting__
+  wx_paint_buffered = instance_method :paint_buffered
+  define_method :paint_buffered do |&block|
+    if instance_variable_defined?('@__painting__')
+      wx_paint_buffered.bind(self).call(&block)
     else
-      # client_size is the window area available for drawing upon
-      c_size = client_size
-      # Create an in-memory buffer if none supplied
-      buffer ||= Wx::Bitmap.new(c_size.width, c_size.height)
-      buffer.draw do | mem_dc |
-        mem_dc.background = Wx::TRANSPARENT_BRUSH
-        mem_dc.clear
-        # Yield the bitmap for the user code to draw upon
-        yield mem_dc
-        paint do | dc |
-          # Copy the buffer to the window
-          dc.blit(0, 0, c_size.width, c_size.height, mem_dc, 0, 0)
-        end
-      end
+      self.paint(&block)
     end
   end
 end

data/lib/wx/doc/array_ext.rb

@@ -0,0 +1,27 @@
+
+module Wx
+
+  # Mixin module providing Array extensions.
+  module ArrayExt
+
+    # Returns a new Wx::Size instance created from the first two elements of the array.
+    # Any missing element will be supplemented by a Wx::DEFAULT_COORD value.
+    # The array is not altered.
+    # @return [Wx::Size]
+    def to_size; end
+
+    # Returns a new Wx::Point instance created from the first two elements of the array.
+    # Any missing element will be supplemented by a Wx::DEFAULT_COORD value.
+    # The array is not altered.
+    # @return [Wx::Point]
+    def to_point; end
+
+    # Returns a new Wx::RealPoint instance created from the first two elements of the array.
+    # Any missing element will be supplemented by a Wx::DEFAULT_COORD value.
+    # The array is not altered.
+    # @return [Wx::RealPoint]
+    def to_real_point; end
+
+  end
+
+end

data/lib/wx/doc/art_locator.rb

@@ -0,0 +1,57 @@
+
+
+# This module provides and standardizes support for locating application art files.
+#
+module Wx::ArtLocator
+
+  # Default name of art folder.
+  ART_FOLDER = 'art'
+
+  class << self
+
+    # Returns the base name for the folder holding application art files.
+    # By default this returns ART_FOLDER
+    # @return [String]
+    def art_folder; end
+
+    # Sets the base name for the folder holding application art files.
+    # @param [String] name art folder base name
+    def art_folder=(name) end
+
+    # Adds one or more search paths to look for art files.
+    # By default ArtLocator#find_art will look only at locations of the caller's
+    # file path. If search paths have been added though these will be searched
+    # after the lookup in the caller's path has failed.
+    def add_search_path(*names) end
+    alias :add_search_paths :add_search_path
+
+    # Searches for the an art file for the given 'art_name'.
+    # By default the search will be performed at the following locations (in order):
+    # 1. <art_path>/<#art_folder>/<art_section>/<art_type>/
+    # 2. <art_path>/<#art_folder>/<art_section>/
+    # 3. <art_path>/<#art_folder>/
+    # 4. <art_path>/
+    # Where 'art_type' is any of <code>:icon</code>, <code>:bitmap</code>, <code>:cursor</code>,
+    # <code>:image</code> or <code>nil</code>. If 'art_type' is nil the first location will be skipped.
+    # In case 'art_path' == <code>nil</code> the absolute path to the folder holding the caller's
+    # code will be used which is determined through ::Kernel#caller_locations.
+    # If 'art_section' is also <code>nil</code> the basename of the caller's source file will be used.
+    # At each location the existence of a file with base name 'art_name' and each of the supported
+    # extensions for the given 'art_type' (see wxWidgets documentation) will be tested. If 'art_type' is nil
+    # all extensions for all supported bitmap types will be tested (similar to when 'art_type' is :image).
+    # If an optional Wx::BitmapType is specified through 'bmp_type' the tested extensions will
+    # be restricted to the extensions supported for specified the bitmap type.
+    #
+    # In case additional search paths have been specified through #add_search_path these will be
+    # searched after the lookup at 'art_path' fails. For each search path the same lookups
+    # will be performed (replacing 'art_path' by the search path).
+    # @param [String,Symbol] art_name base name for art file
+    # @param [Symbol,nil] art_type type of art to look for (:icon, :bitmap, :cursor, :image)
+    # @param [String,nil] art_path base path to look up the art file
+    # @param [String,nil] art_section optional owner folder name for art files
+    # @param [Wx::BitmapType,nil] bmp_type bitmap type of art file
+    def find_art(art_name, art_type: nil, art_path: nil, art_section: nil, bmp_type: nil) end
+
+  end
+
+end

data/lib/wx/doc/bitmap.rb

@@ -0,0 +1,27 @@
+
+module Wx
+
+  # Default BitmapType for current platform. Actual value is platform dependent.
+  ICON_DEFAULT_TYPE = Wx::BitmapType::BITMAP_TYPE_ANY
+  # Default BitmapType for current platform. Actual value is platform dependent.
+  BITMAP_DEFAULT_TYPE = Wx::BitmapType::BITMAP_TYPE_ANY
+  # Default BitmapType for current platform. Actual value is platform dependent.
+  CURSOR_DEFAULT_TYPE = Wx::BitmapType::BITMAP_TYPE_ANY
+
+  class Bitmap
+
+    # Searches for an art file with basename 'name' and creates a Bitmap 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)
+    # @return [Wx::Bitmap]
+    # @see Wx::ArtLocator::find_art
+    def self.Bitmap(name, bmp_type = nil); end
+
+  end
+
+end

data/lib/wx/doc/clipboard.rb

@@ -0,0 +1,12 @@
+
+class Wx::Clipboard
+
+  alias :place :set_data
+  alias :fetch :get_data
+
+  # Opens the global clipboard and passes the clipboard object to the block.
+  # @yieldparam [Wx::Clipboard] clip the global clipboard object
+  # @return [Object] block result
+  def self.open; end
+
+end