wxruby3 0.9.0.pre.beta.9 → 0.9.0.pre.beta.11

data/lib/wx/core/controlwithitems.rb

@@ -1,10 +1,106 @@
 # Superclass of a variety of controls that display lists of items (eg
 # Choice, ListBox, CheckListBox)
 class Wx::ControlWithItems
-  # Make these ruby enumerables so find, find_all, map etc are available 
+
+  # Make these Ruby enumerables so find, find_all, map etc are available
   include Enumerable
+
   # Passes each valid item index into the passed block
   def each
-    0.upto(get_count - 1) { | i | yield i }
+    get_count.times { | i | yield i }
+  end
+
+  # We need to cache client data in Ruby variables as we cannot access items
+  # during the GC mark phase as for some platforms (WXMSW at least) that would
+  # involve calling methods that would break in that phase.
+
+  def client_data_store
+    @client_data ||= []
+  end
+  private :client_data_store
+
+  wx_set_client_data = instance_method :set_client_data
+  define_method :set_client_data do |item, data|
+    item = item.to_i
+    wx_set_client_data.bind(self).call(item, data)
+    client_data_store[item] = data
+  end
+
+  def get_client_data(item)
+    client_data_store[item.to_i]
+  end
+
+  wx_append = instance_method :append
+  define_method :append do |item, data=nil|
+    if data
+      if ::Array === item
+        if !(::Array === data)
+          ::Kernel.raise ::TypeError.new("Expected Array for argument 3")
+        elsif data.size != item.size
+          ::Kernel.raise ::ArgumentError.new("item and data array must be equal size")
+        end
+        offs = get_count
+        wx_append.bind(self).call(item)
+        item.size.times { |ix| set_client_data(offs+ix, data[ix]) }
+      else
+        wx_append.bind(self).call(item, data)
+        client_data_store[get_count-1] = data
+      end
+    else
+      wx_append.bind(self).call(item)
+      # no changes to data store
+    end
+  end
+
+  wx_insert = instance_method :insert
+  define_method :insert do |item, pos, data=nil|
+    if data
+      if ::Array === item
+        if !(::Array === data)
+          ::Kernel.raise ::TypeError.new("Expected Array for argument 3")
+        elsif data.size != item.size
+          ::Kernel.raise ::ArgumentError.new("item and data array must be equal size")
+        end
+        wx_insert.bind(self).call(item, pos)
+        client_data_store.insert(pos, *::Array.new(item.size))
+        item.size.times { |ix| set_client_data(pos+ix, data[ix]) }
+      else
+        wx_insert.bind(self).call(item, pos, data)
+        client_data_store.insert(pos, data)
+      end
+    else
+      wx_insert.bind(self).call(item, pos)
+      if ::Array === item
+        client_data_store.insert(pos, *::Array.new(item.size))
+      else
+        client_data_store.insert(pos, nil)
+      end
+    end
+  end
+
+  wx_set = instance_method :set
+  define_method :set do |items, data=nil|
+    if data
+      if !(::Array === data)
+        ::Kernel.raise ::TypeError.new("Expected Array for argument 2")
+      elsif data.size != items.size
+        ::Kernel.raise ::ArgumentError.new("items and data array must be equal size")
+      end
+    end
+    wx_set.bind(self).call(items)
+    client_data_store.clear
+    items.each_with_index { |item, ix| set_client_data(item, data[ix]) }
+  end
+
+  wx_clear = instance_method :clear
+  define_method :clear do
+    wx_clear.bind(self).call
+    client_data_store.clear
+  end
+
+  wx_delete = instance_method :delete
+  define_method :delete do |item|
+    wx_delete.bind(self).call(item.to_i)
+    client_data_store.slice!(item.to_i)
   end
 end

data/lib/wx/core/data_object.rb

@@ -1,10 +1,78 @@
-# Provide some default implementations of these to make life easier
-class Wx::DataObject
-  def get_preferred_format(direction)
-    get_all_formats(direction).first
+
+module Wx
+
+  # Provide some default implementations of these to make life easier
+  class DataObject
+    def get_preferred_format(direction)
+      get_all_formats(direction).first
+    end
+
+    def get_format_count(direction)
+      get_all_formats(direction).size
+    end
   end
 
-  def get_format_count(direction)
-    get_all_formats(direction).size
+  class DataObjectSimple
+
+    # implement the overloads which do not require the format arg
+    # using pure Ruby
+
+    wx_get_data_size = instance_method :get_data_size
+    define_method :get_data_size do |format = nil|
+      wx_get_data_size.bind(self).call(format || self.get_format)
+    end
+
+    wx_get_data_here = instance_method :get_data_here
+    define_method :get_data_here do |format = nil|
+      wx_get_data_here.bind(self).call(format || self.get_format)
+    end
+
+    wx_set_data = instance_method :set_data
+    define_method :set_data do |*args|
+      if args.size>1
+        format, buf = args
+      else
+        format = nil
+        buf = args.first
+      end
+      wx_set_data.bind(self).call(format || self.get_format, buf)
+    end
+
   end
+
+  class DataObjectSimpleBase
+
+    # implement these in pure Ruby for optimization
+    def get_data_size(*)
+      self._get_data_size
+    end
+    def get_data_here(*)
+      self._get_data
+    end
+
+    def set_data(*args)
+      if args.size>1
+        _, buf = args
+      else
+        buf = args.first
+      end
+      self._set_data(buf)
+    end
+
+    def _get_data_size
+      (_get_data || '').bytesize
+    end
+    protected :_get_data_size
+
+  end
+
+  class TextDataObject
+
+    # override this to loose the extra terminating 0 we otherwise get
+    def get_data_here(*)
+      self.get_text
+    end
+
+  end
+
 end

data/lib/wx/core/icon.rb

@@ -14,12 +14,18 @@ class Wx::Icon
 
   def to_bitmap
     # for WXMSW platform Icon is not derived from Bitmap
-    return self unless Wx::PLATFORM == 'WXMSW'
+    return self unless Wx::PLATFORM == 'WXMSW' || Wx::PLATFORM == 'WXOSX'
     bm = Wx::Bitmap.new
     bm.copy_from_icon(self)
     bm
   end
 
+  if Wx::PLATFORM == 'WXMSW' || Wx::PLATFORM == 'WXOSX'
+    def convert_to_image
+      to_bitmap.convert_to_image
+    end
+  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 empty icon, which may cause faults

data/lib/wx/core/imagelist.rb

@@ -1,3 +1,14 @@
+
 class Wx::ImageList
+
+  # provide seamless support for adding icons on all platforms
+  wx_add = instance_method :add
+  define_method :add do |*args|
+    if Wx::Icon === args.first
+      args[0] = args.first.to_bitmap
+    end
+    wx_add.bind(self).call(*args)
+  end
+
   alias :<< :add
 end

data/lib/wx/core/listbox.rb

@@ -1,3 +1,6 @@
+
+require_relative './controlwithitems'
+
 class Wx::ListBox
   alias :get_item_data :get_client_data
   alias :set_item_data :set_client_data

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,9 @@ 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
 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,9 @@ class Wx::RealPoint
       end
     end
   end
+
+
+  def to_point
+    Wx::Point.new(self.x.to_i, self.y.to_i)
+  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

data/lib/wx/core/size.rb

@@ -1,4 +1,7 @@
 class Wx::Size
+
+  include Comparable
+
   # More informative output for inspect etc
   def to_s
     "#<Wx::Size: #{width}x#{height}>"
@@ -14,24 +17,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)

data/lib/wx/doc/data_object.rb

@@ -0,0 +1,104 @@
+
+module Wx
+
+  class DataObject
+
+    # Returns the data size of the given format.
+    # Should be overridden in derived classes.
+    # @note **IMPORTANT** Please note that it is necessary to return the **size in bytes** of the data string
+    # returned by #get_data_here (not the size in characters).
+    # @param format [Wx::DataFormat]
+    # @return [Integer]
+    def get_data_size(format) end
+    alias_method :data_size, :get_data_size
+
+  end
+
+  # This is an (abstract in Ruby) base class for the simplest possible custom data objects.
+  # Unlike in C++ in Ruby this class cannot be used to derive custom data objects from but
+  # instead {Wx::DataObjectSimpleBase} (derived from Wx::DataObjectSimple) should be used.
+  # The data object of (a class derived from) this class only supports <b>one format</b>,
+  # so the number of virtual functions to be implemented is reduced.
+  # This class is the base class for {Wx::TextDataObject}, {Wx::FileDataObject}, {Wx::BitmapDataObject},
+  # {Wx::wxCustomDataObject} and others.
+  # ===
+  #
+  # Category:  Clipboard and Drag & Drop
+  # @see Drag and Drop Overview
+  # @see  Drag & Drop Sample
+  class DataObjectSimple < DataObject
+
+    # @overload get_data_size(format)
+    #   Returns the data size of the format for this object.
+    #   @param [Wx::DataFormat] format ignored for this class
+    #   @return [Integer] default always returns 0
+    # @overload get_data_size()
+    #   Returns the data size of the format for this object.
+    #   @return [Integer] default always returns 0
+    def get_data_size(*) end
+
+    # @overload get_data_here(format)
+    #   Returns the data of this object.
+    #   @param [Wx::DataFormat] format ignored for this class
+    #   @return [String,nil] data of this object
+    # @overload get_data_here()
+    #   Returns the data of this object.
+    #   @return [String,nil] data of this object
+    def get_data_here(*) end
+
+    # @overload set_data(format, buf)
+    #   Sets the data for this object and returns true if successful, false otherwise.
+    #   @param [Wx::DataFormat] format ignored for this class
+    #   @param [String] buf non-nil data
+    #   @return [Boolean] default always returns false.
+    # @overload set_data(buf)
+    #   Sets the data for this object and returns true if successful, false otherwise.
+    #   @param [String] buf non-nil data
+    #   @return [Boolean] default always returns false.
+    def set_data(*) end
+
+  end
+
+  # This is the base class for the simplest possible custom data objects.
+  # The data object of (a class derived from) this class only supports <b>one format</b>,
+  # so the number of methods to be implemented is reduced.
+  # To be useful it must be derived. Derived objects supporting rendering the data must
+  # override {Wx::DataObjectSimpleBase#_get_data_size} and {Wx::DataObjectSimpleBase#_get_data}.
+  # By default these methods respectively return <code>0</code> and <code>nil</code>.
+  # The objects which may be set must override {Wx::DataObjectSimpleBase#_set_data} (which
+  # returns <code>false</code>).
+  # Of course, the objects supporting both operations must override all three methods.
+  # ===
+  #
+  # Category:  Clipboard and Drag & Drop
+  # @see Drag and Drop Overview
+  # @see  Drag & Drop Sample
+  # @see  Wx::DataObjectSimple
+  class DataObjectSimpleBase < DataObjectSimple
+
+    # Returns this object's data size.
+    # The default implementation calls #_get_data and determines the size of the returned data string (if any).
+    # As this is not very optimal for more complex (and larger data objects) very often this method will be
+    # overridden in derived classes.
+    # @note **IMPORTANT** Please note that it is necessary to return the **size in bytes** of the data string
+    # returned by #_get_data (not the size in characters).
+    # @return [Integer]
+    def _get_data_size; end
+    protected :_get_data_size
+
+    # Returns this object's data (default implementation returns nil).
+    # Should be overridden in derived classes.
+    # @return [String,nil]
+    def _get_data; end
+    protected :_get_data
+
+    # Sets this object's data (default implementation does nothing and returns false).
+    # Should be overridden in derived classes.
+    # @param [String] buf non-nil data
+    # @return [Boolean]
+    def _set_data(buf); end
+    protected :_set_data
+
+  end
+
+end

data/lib/wx/doc/gdi_common.rb

@@ -56,20 +56,27 @@ module Wx
 
   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 +104,18 @@ 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
+
   end
 
   class RealPoint
 
+    include Comparable
+
     # Returns point array (`[x, y]`)
     # @return [Array(Float,Float)] point as array
     def to_ary; end
@@ -111,11 +125,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 +168,10 @@ 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
+
   end
 
   class Rect
@@ -152,7 +180,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

data/lib/wx/doc/progress_dialog.rb

@@ -0,0 +1,37 @@
+
+class Wx::ProgressDialog
+
+  # Updates the dialog, setting the progress bar to the new value and updating the message if new one is specified.
+  #
+  # Returns <code>false</code> if the "Cancel" button has been pressed, <code>true</code> if neither "Cancel" nor
+  # "Skip" has been pressed and <code>:skipped</code> if "Skip" has been pressed.
+  #
+  # If false is returned, the application can either immediately destroy the dialog or ask the user for the confirmation
+  # and if the abort is not confirmed the dialog may be resumed with #resume method.
+  #
+  # If value is the maximum value for the dialog, the behaviour of the function depends on whether Wx::PD_AUTO_HIDE was
+  # used when the dialog was created. If it was, the dialog is hidden and the function returns immediately. If it was
+  # not, the dialog becomes a modal dialog and waits for the user to dismiss it, meaning that this function does not
+  # return until this happens.
+  #
+  # Notice that if newmsg is longer than the currently shown message, the dialog will be automatically made wider to
+  # account for it. However if the new message is shorter than the previous one, the dialog doesn't shrink back to
+  # avoid constant resizes if the message is changed often. To do this and fit the dialog to its current contents you
+  # may call fit explicitly. An alternative would be to keep the number of lines of text constant in order to avoid
+  # jarring dialog size changes. You may also want to make the initial message, specified when creating the dialog,
+  # wide enough to avoid having to resize the dialog later, e.g. by appending a long string of unbreakable spaces
+  # (wxString(L'\u00a0', 100)) to it.
+  # @param [Integer] value The new value of the progress meter. It should be less than or equal to the maximum value given to the constructor.
+  # @param [String] newmsg The new messages for the progress dialog text, if it is empty (which is the default) the message is not changed.
+  # @return [Boolean,:skipped]
+  def update(value, newmsg = '') end
+
+  # Like #update but makes the gauge control run in indeterminate mode.
+  #
+  # In indeterminate mode the remaining and the estimated time labels (if present) are set to "Unknown" or to newmsg
+  # (if it's non-empty). Each call to this function moves the progress bar a bit to indicate that some progress was done.
+  # @param [String] newmsg
+  # @return [Boolean,:skipped]
+  def pulse(newmsg = '') end
+
+end

data/lib/wx/doc/scaled_dc.rb

@@ -0,0 +1,16 @@
+
+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
+    def self.draw_on(target, scale) end
+  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.9'
+  WXRUBY_VERSION    = '0.9.0-beta.11'
 end