wxruby3 0.9.0.pre.beta.8-x64-mingw-ucrt

data/lib/wx/core/image.rb

@@ -0,0 +1,68 @@
+# A platform-independent image; can be manipulated more extensively than
+# Bitmap, but must be converted to a Bitmap for drawing.
+class Wx::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
+      end
+    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
+
+  # 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
+
+  # Create a new image from Wx::Bitmap, preserving mask information
+  def self.from_bitmap(bmp)
+    bmp.convert_to_image
+  end
+
+  # 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
+end

data/lib/wx/core/imagelist.rb

@@ -0,0 +1,3 @@
+class Wx::ImageList
+  alias :<< :add
+end

data/lib/wx/core/listbox.rb

@@ -0,0 +1,4 @@
+class Wx::ListBox
+  alias :get_item_data :get_client_data
+  alias :set_item_data :set_client_data
+end

data/lib/wx/core/listctrl.rb

@@ -0,0 +1,33 @@
+# Multi-item control with numerous possible view styles
+class Wx::ListCtrl
+  # Make these ruby enumerables so find, find_all, map are available 
+  include Enumerable
+  # Passes each valid item index into the passed block
+  def each
+    0.upto(item_count - 1) { | i | yield i }
+  end
+
+  # Returns an Array containing the indexes of the currently selected
+  # items 
+  def get_selections
+    selections = []
+    item = get_next_item(-1, Wx::LIST_NEXT_ALL, Wx::LIST_STATE_SELECTED)
+    while item >= 0
+      selections << item
+      item = get_next_item(item, Wx::LIST_NEXT_ALL, Wx::LIST_STATE_SELECTED) 
+    end
+    selections
+  end
+
+  # # Stub version for LC_VIRTUAL controls that does nothing; may be
+  # # overridden in subclasses.
+  # def on_get_item_attr(i)
+  #   nil
+  # end
+  #
+  # # Stub version for LC_VIRTUAL|LC_REPORT controls that does nothing;
+  # # may be overridden in subclasses.
+  # def on_get_item_column_image(i, col)
+  #   -1
+  # end
+end

data/lib/wx/core/locale.rb

@@ -0,0 +1,73 @@
+class Wx::Locale
+  class << self
+    def get_system_language_name
+      get_language_name( get_system_language )
+    end
+    
+    def get_system_encoding_name
+      Wx::Font::ENCODING_NAMES[ get_system_encoding ]
+    end
+
+    # Set the current locale by a name, canonical name, or Wx::LANGUAGE_
+    # constant; mainly here because it seems a bit strange in Ruby to
+    # have global side-effects in a constructor
+    def set_locale(locale)
+      if ::Integer === locale || Wx::Enum === locale
+        new(locale)
+      elsif ::String === locale and (lang_info = find_language_info(locale))
+        new(lang_info.language)
+      else
+        raise ArgumentError, "Unknown language #{locale}"
+      end
+    end
+
+    # as wxWidgets defines an enum wxLanguage but still uses a mix of enum args and int args
+    # to specify languages we need to fix some things here to make that easier
+    wx_is_available = Wx::Locale.method(:is_available)
+    define_method :is_available do |lang|
+      wx_is_available.call(lang.to_i)
+    end
+
+    wx_get_language_info = Wx::Locale.method(:get_language_info)
+    define_method :get_language_info do |lang|
+      wx_get_language_info.call(lang.to_i)
+    end
+
+    wx_get_language_name = Wx::Locale.method(:get_language_name)
+    define_method :get_language_name do |lang|
+      wx_get_language_name.call(lang.to_i)
+    end
+
+    wx_get_language_canonical_name = Wx::Locale.method(:get_language_canonical_name)
+    define_method :get_language_canonical_name do |lang|
+      wx_get_language_canonical_name.call(lang.to_i)
+    end
+  end
+
+  # as wxWidgets defines an enum wxLanguage but still uses a mix of enum args and int args
+  # to specify languages we need to fix some things here to make that easier
+  alias :wx_initialize :initialize
+  def initialize(*args)
+    if args.empty? || ::String === args.first
+      wx_initialize(*args)
+    else
+      wx_initialize(args.shift.to_i, *args)
+    end
+  end
+
+  # as wxWidgets defines an enum wxLanguage but still uses a mix of enum args and int args
+  # to specify languages we need to fix some things here to make that easier
+  wx_init = instance_method(:init)
+  define_method :init do |*args|
+    if args.empty? || ::String === args.first
+      wx_init.bind(self).call(*args)
+    else
+      wx_init.bind(self).call(args.shift.to_i, *args)
+    end
+  end
+
+  def get_language_name
+    self.class.get_language_name(get_language)
+  end
+
+end

data/lib/wx/core/log.rb

@@ -0,0 +1,20 @@
+
+module Wx
+
+  class Log
+    class << self
+      alias :active_target= :set_active_target
+      alias :active_target :get_active_target
+      alias :log_level :get_log_level
+      alias :log_level= :set_log_level
+      alias :enabled? :is_enabled
+      alias :repetition_counting :get_repetition_counting
+      alias :repetition_counting= :set_repetition_counting
+      alias :timestamp :get_timestamp
+      alias :timestamp= :set_timestamp
+      alias :verbose :get_verbose
+      alias :verbose= :set_verbose
+    end
+  end
+
+end

data/lib/wx/core/menu.rb

@@ -0,0 +1,78 @@
+# A single labelled list within a drop-down menu, or a popup menu
+class Wx::Menu
+
+  alias :wx_initialize :initialize
+
+  def initialize(*args, &block)
+    wx_initialize(*args)
+    if block
+      if block.arity == -1 or block.arity == 0
+        self.instance_eval(&block)
+      elsif block.arity == 1
+        block.call(self)
+      else
+        Kernel.raise ArgumentError,
+                     "Block to initialize should accept a single argument or none"
+      end
+    end
+  end
+
+  # In the standard WxWidgets API, the methods append, prepend, insert
+  # (and their variants) require a constant integer id as the identifier
+  # of the menu item. This is then used in event handling. 
+  #
+  # In WxRuby the use of explicit ids can be avoided in most cases,
+  # being a most unruby-ish practice. So, by analogy with the general
+  # use of Wx::Window classes and event handlers, where the id is
+  # implicit in the constructor, and the window can be passed direct to
+  # the event handler setup method, the below sets up a similar facility
+  # for adding items to Wx::Menu.
+  #
+  # For all these methods, the only required argument is the string name
+  # of the menu item; a system-default id will be supplied if no
+  # explicit one is given. The return value of these methods in all
+  # cases is a Wx::MenuItem object, which can be passed directly as the
+  # first argument to an evt_menu handler.
+  def self.methods_with_optional_ids(*meth_names)
+    class_eval do 
+      meth_names.each do | meth |
+        old_meth = instance_method(meth)
+        define_method(meth) do | *args |
+          case args.first
+            when Integer, Wx::Enum then old_meth.bind(self).call(*args)
+            when String then old_meth.bind(self).call(Wx::ID_ANY, *args)
+            when Wx::MenuItem then old_meth.bind(self).call(args.first)
+          end
+        end
+      end
+    end
+  end
+
+  # Create the optional-id methods
+  methods_with_optional_ids :append, :prepend,
+                            :append_check_item, :prepend_check_item, 
+                            :append_radio_item, :prepend_radio_item
+
+  # This is much the same as above, except for insert and variants,
+  # which take an additional first argument, the position at which to
+  # insert the new item.
+  def self.methods_with_optional_ids_and_pos(*meth_names)
+    class_eval do 
+      meth_names.each do | meth |
+        old_meth = instance_method(meth)
+        define_method(meth) do | pos, *args |
+          case args.first
+            when Integer, Wx::Enum then old_meth.bind(self).call(pos, *args)
+            when String then old_meth.bind(self).call(pos, Wx::ID_ANY, *args)
+            when Wx::MenuItem then old_meth.bind(self).call(pos, args.first)
+          end
+        end
+      end
+    end
+  end
+
+  # Create the optional-id methods
+  methods_with_optional_ids_and_pos :insert,
+                                    :insert_check_item,
+                                    :insert_radio_item
+end

data/lib/wx/core/menu_bar.rb

@@ -0,0 +1,20 @@
+
+class Wx::MenuBar
+
+  alias :wx_initialize :initialize
+
+  def initialize(*args, &block)
+    wx_initialize(*args)
+    if block
+      if block.arity == -1 or block.arity == 0
+        self.instance_eval(&block)
+      elsif block.arity == 1
+        block.call(self)
+      else
+        Kernel.raise ArgumentError,
+                     "Block to initialize should accept a single argument or none"
+      end
+    end
+  end
+
+end

data/lib/wx/core/menuitem.rb

@@ -0,0 +1,7 @@
+# An individual item within a frame or popup menu
+class Wx::MenuItem
+  # Get the Wx id, not Ruby's deprecated Object#id
+  alias :id :get_id
+  # In case a more explicit option is preferred.
+  alias :wx_id :get_id
+end

data/lib/wx/core/notebook.rb

@@ -0,0 +1,9 @@
+# Displays a set of pages in parallel using tabs
+class Wx::Notebook
+  # Convenience method for iterating pages
+  def each_page
+    0.upto(get_page_count - 1) do | i |
+      yield get_page(i)
+    end
+  end
+end

data/lib/wx/core/object.rb

@@ -0,0 +1,14 @@
+# The root class for most (not all) WxRuby classes
+class Wx::Object
+  # Massage the output of inspect to show the public module name (Wx),
+  # instead of the internal name (Wxruby2)
+  # def to_s
+  #   super.sub('ruby2', '')
+  # end
+
+  # Returns a string containing the C++ pointer address of this
+  # object. Only useful for debugging.
+  def ptr_addr
+    Wx::ptr_addr(self)
+  end
+end

data/lib/wx/core/pen_info.rb

@@ -0,0 +1,11 @@
+
+class Wx::PenInfo
+
+  # make Wx::PenInfo#dashes return self
+  wx_dashes = instance_method :dashes
+  define_method :dashes do |*args|
+    wx_dashes.bind(self).call(*args)
+    self
+  end
+
+end

data/lib/wx/core/platform_info.rb

@@ -0,0 +1,13 @@
+
+module Wx
+
+  class PlatformInfo
+
+    # make all methods of the singleton accessible through the class
+    def self.method_missing(sym, *args)
+      Wx::PlatformInfo.instance.__send__(sym, *args)
+    end
+
+  end
+
+end

data/lib/wx/core/point.rb

@@ -0,0 +1,92 @@
+class Wx::Point
+  # More informative output when converted to string
+  def to_s
+    "#<Wx::Point: (#{x}, #{y})>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  # make Point usable for parallel assignments like `x, y = pt`
+  def to_ary
+    [x, y]
+  end
+
+  alias :get_x :x
+  alias :get_y :y
+
+  # Compare point values
+  def ==(other)
+    if Wx::Point === other
+      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}"
+    end
+  end
+
+  # Correct comparison for Points - same if same x and y
+  def eql?(other)
+    if Wx::Point === other
+      x == other.x and y == other.y
+    else
+      false
+    end
+  end
+
+  # Return a new Wx::Point with the x and y parameters both divided by
+  # parameter +num+, which should be a Numeric
+  def /(num)
+    self.class.new((get_x / num).to_i, (get_y / num).to_i)
+  end
+
+  # Return a new Wx::Point with the x and y values both multiplied by
+  # parameter +num+, which should be a Numeric
+  def *(num)
+    self.class.new((get_x * num).to_i, (get_y * num).to_i)
+  end
+
+  # Return a new Wx::Point with the x and y values both reduced by
+  # parameter +arg+. If +arg+ is another Wx::Point (or Wx::Size or 2-element array), reduce x by the
+  # other's x (or width) and y by the other's y (or height); if +arg+ is a numeric value,
+  # reduce x and y both by that value.
+  def -(arg)
+    case arg
+    when self.class
+      self.class.new(get_x - arg.x, get_y - arg.y)
+    when Wx::Size
+      self.class.new(get_x - arg.width,get_y - arg.height)
+    when Numeric
+      self.class.new((get_x - arg).to_i, (get_y - arg).to_i)
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(get_x - arg[0].to_i, get_y - arg[1].to_i)
+      else
+        Kernel.raise TypeError, "Cannot subtract #{arg} from #{self.inspect}"
+      end
+    end
+  end
+
+  # Return a new Wx::Point with the x and y values both increased by
+  # parameter +arg+. If +arg+ is another Wx::Point (or Wx::Size or 2-element array), increase x by the
+  # other's x (or width) and y by the other's y (or height); if +arg+ is a numeric value,
+  # increase both x and y by that value.
+  def +(arg)
+    case arg
+    when self.class
+      self.class.new(get_x + arg.x, get_y + arg.y)
+    when Wx::Size
+      self.class.new(get_x + arg.width,get_y + arg.height)
+    when Numeric
+      self.class.new((get_x + arg).to_i, (get_y + arg).to_i)
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(get_x + arg[0].to_i, get_y + arg[1].to_i)
+      else
+        Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+      end
+    end
+  end
+end

data/lib/wx/core/real_point.rb

@@ -0,0 +1,92 @@
+class Wx::RealPoint
+  # More informative output when converted to string
+  def to_s
+    "#<Wx::RealPoint: (#{x}, #{y})>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  # make RealPoint usable for parallel assignments like `x, y = pt`
+  def to_ary
+    [x, y]
+  end
+
+  alias :get_x :x
+  alias :get_y :y
+
+  # Compare point values
+  def ==(other)
+    if Wx::RealPoint === other
+      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}"
+    end
+  end
+
+  # Correct comparison for RealPoints - same if same x and y
+  def eql?(other)
+    if Wx::RealPoint === other
+      x == other.x and y == other.y
+    else
+      false
+    end
+  end
+
+  # Return a new Wx::RealPoint with the x and y parameters both divided by
+  # parameter +num+, which should be a Numeric
+  def /(num)
+    self.class.new( get_x / num, get_y / num )
+  end
+
+  # Return a new Wx::RealPoint with the x and y values both multiplied by
+  # parameter +num+, which should be a Numeric
+  def *(num)
+    self.class.new( get_x * num, get_y * num )
+  end
+
+  # Return a new Wx::RealPoint with the x and y values both reduced by
+  # parameter +arg+. If +arg+ is another Wx::(Real)Point (or Wx::Size or 2-element array), reduce x by the
+  # other's x (or width) and y by the other's y (or height); if +arg+ is a numeric value,
+  # reduce x and y both by that value.
+  def -(arg)
+    case arg
+    when Wx::Size
+      self.class.new(get_x - arg.width, get_y - arg.height)
+    when self.class, Wx::Point
+      self.class.new(get_x - arg.x, get_y - arg.y)
+    when Numeric
+      self.class.new(get_x - arg, get_y - arg)
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(get_x - arg[0].to_f, get_y - arg[1].to_f)
+      else
+        Kernel.raise TypeError, "Cannot subtract #{arg} from #{self.inspect}"
+      end
+    end
+  end
+
+  # Return a new Wx::RealPoint with the x and y values both increased by
+  # parameter +arg+. If +arg+ is another Wx::(Real)Point (or Wx::Size or 2-element array), increase x by the
+  # other's x (or width) and y by the other's y (or height); if +arg+ is a numeric value,
+  # increase both x and y by that value.
+  def +(arg)
+    case arg
+    when Wx::Size
+      self.class.new(get_x + arg.width, get_y + arg.height)
+    when self.class, Wx::Point
+      self.class.new(get_x + arg.x, get_y + arg.y)
+    when Numeric
+      self.class.new(get_x + arg, get_y + arg)
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(get_x + arg[0].to_f, get_y + arg[1].to_f)
+      else
+        Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+      end
+    end
+  end
+end

data/lib/wx/core/rect.rb

@@ -0,0 +1,57 @@
+# Class representing a rectangular shape
+class Wx::Rect
+  # Nicely readable inspect output for Rect
+  def to_s
+    "#<Wx::Rect: (#{left}, #{top}) #{width}x#{height}>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  # make Rect usable for parallel assignments like `left, top, width, height = rect`
+  def to_ary
+    [left, top, width, height]
+  end
+
+  # Correct comparison for Wx::Rect, are the same if have the same
+  # position and the same size
+  def ==(other)
+    if Wx::Rect === other
+      left == other.left and top == other.top and
+        width == other.width and height == other.height
+    elsif Array === other && other.size == 4
+      to_ary == other
+    else
+      Kernel.raise TypeError, "Cannot compare Rect to #{other}"
+    end
+  end
+
+  def eql?(other)
+    if Wx::Rect === other
+      left == other.left and top == other.top and
+        width == other.width and height == other.height
+    else
+      false
+    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)
+  end
+
+  wx_intersect = instance_method :intersect
+  define_method :intersect do |rect|
+    wx_intersect.bind(Wx::Rect.new(*self.to_ary)).call(rect)
+  end
+
+  alias :+ :add
+  alias :* :mul
+  alias :& :intersect
+  alias :| :union
+
+  # More ruby-ish names
+  alias :contains? :contains
+end

data/lib/wx/core/simplehelpprovider.rb

@@ -0,0 +1,38 @@
+# Pure-ruby implementation of the corresponding Wx class. Simply shows
+# the Window's help text in a tooltip.
+class Wx::SimpleHelpProvider < Wx::HelpProvider
+  def initialize
+    super
+    # Store for mapping windows -> help strings
+    @help_wins = {} 
+    # Store for mapping ids -> help strings
+    @help_ids  = {}
+  end
+
+  # This is what is called by Wx::Window#set_help_text
+  def add_help(identifier, text)
+    if identifier.kind_of? Wx::Window
+      @help_wins[identifier.object_id] = text
+    else
+      @help_ids[identifier] = text
+    end
+  end
+
+  # Retrieve help text for the given window +win+
+  def get_help(win)
+    @help_wins[win.object_id] || @help_ids[win.wx_id] || ""
+  end
+
+  # Remove the help text for +win+
+  def remove_help(win)
+    @help_wins.delete(win.object_id)
+  end
+
+  # Show help for +win+
+  def show_help(win)
+    help_text = get_help(win)
+    return false if help_text.empty?
+    tip = Wx::TipWindow.new(win, help_text, 100)
+    true
+  end
+end