wxruby64 2.0.1-x64-mingw32

data/lib/wx/classes/iconbundle.rb

@@ -0,0 +1,3 @@
+class Wx::IconBundle
+  alias :<< :add_icon
+end

data/lib/wx/classes/image.rb

@@ -0,0 +1,53 @@
+# A platform-independent image; can be manipulated more extensively than
+# Bitmap, but must be converted to a Bitmap for drawing.
+class Wx::Image
+  
+  # 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 'wx/classes/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/classes/imagelist.rb

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

data/lib/wx/classes/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/classes/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/classes/locale.rb

@@ -0,0 +1,28 @@
+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 locale.kind_of?(Fixnum)
+        new(locale)
+      elsif locale.kind_of?(String) and lang_info = find_language_info(locale)
+        new(lang_info.language)
+      else
+        raise ArgumentError, "Unknown language #{locale}"
+      end
+    end
+  end
+
+  def get_language_name
+    self.class.get_language_name(get_language)
+  end
+end

data/lib/wx/classes/mediactrl.rb

@@ -0,0 +1,48 @@
+# Functionality here must be loaded first to add custom events
+require 'wx/classes/evthandler'
+
+# These event handlers should only be defined if MediaCtrl is actually
+# available; some builds may not include it
+if defined?(Wx::MediaCtrl)
+  evt_type = Wx::EvtHandler::EventType
+  mediactrl_event_types = [
+    evt_type['evt_media_finished', 1,
+              Wx::EVT_MEDIA_FINISHED,
+              Wx::MediaEvent],
+    evt_type['evt_media_loaded', 1,
+              Wx::EVT_MEDIA_LOADED,
+              Wx::MediaEvent],
+    evt_type['evt_media_pause', 1,
+              Wx::EVT_MEDIA_PAUSE,
+              Wx::MediaEvent],
+    evt_type['evt_media_play', 1,
+              Wx::EVT_MEDIA_PLAY,
+              Wx::MediaEvent],
+    evt_type['evt_media_statechanged', 1,
+              Wx::EVT_MEDIA_STATECHANGED,
+              Wx::MediaEvent],
+    evt_type['evt_media_stop', 1,
+              Wx::EVT_MEDIA_STOP,
+              Wx::MediaEvent]
+  ]
+  mediactrl_event_types.each do | ev_type | 
+    Wx::EvtHandler.register_event_type(ev_type)
+  end
+
+  # Extend with a nicer interface to get_state
+  class Wx::MediaCtrl
+    # Returns true if the media is currently paused, else false
+    def is_paused
+      get_state == Wx::MEDIASTATE_PAUSED
+    end
+    # Returns true if the media is currently playing, else false
+    def is_playing
+      get_state == Wx::MEDIASTATE_PLAYING
+    end
+    # Returns true if the media is currently stopped, else false
+    def is_stopped
+      get_state == Wx::MEDIASTATE_STOPPED
+    end
+  end
+end
+

data/lib/wx/classes/menu.rb

@@ -0,0 +1,62 @@
+# A single labelled list within a drop-down menu, or a popup menu
+class Wx::Menu
+
+  # 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 Fixnum 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 Fixnum 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/classes/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/classes/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/classes/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/classes/paintdc.rb

@@ -0,0 +1,12 @@
+# Device Context to paint within an on_paint handler
+class Wx::PaintDC
+  # This class should not be instantiated directly in wxRuby; it should
+  # always be used via Window#paint, which takes a block receiving the
+  # DC. This ensures that the DC is cleaned up at the correct time,
+  # preventing serious errors on some platforms.
+  define_method(:initialize) do | *args |
+    Kernel.raise RuntimeError,
+                 "Do not instantiate PaintDC directly; use Window#paint",
+                 caller[1..-1]
+  end
+end

data/lib/wx/classes/point.rb

@@ -0,0 +1,56 @@
+class Wx::Point
+  # More informative output when converted to string
+  def to_s
+    "#<Wx::Point: (#{x}, #{y})>"
+  end
+
+  # Correct comparison for Points - same if same x and y
+  def ==(other)
+    unless other.kind_of?(Wx::Point)
+      Kernel.raise TypeError, "Cannot compare Point to #{other}"
+    end
+    x == other.x and y == other.y
+  end
+
+  # Return a new Wx::Point with the x and y parameters both divided by
+  # parameter +div+, which should be a Numeric
+  def /(div)
+    self.class.new( (get_x / div).to_i, (get_y / div).to_i )
+  end
+
+  # Return a new Wx::Point with the x and y values both multiplied by
+  # parameter +mul+, which should be a Numeric
+  def *(mul)
+    self.class.new( (get_x * mul).to_i, (get_y * mul).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, reduce x by the
+  # other's x and y by the other's y; 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.get_x, get_y - arg.get_y )
+    when Numeric
+      self.class.new( (get_x - arg).to_i, (get_y - arg).to_i )
+    else
+      Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+    end
+  end
+
+  # Return a new Wx::Point with the x and y values both increased by
+  # parameter +arg+. If +arg+ is another Wx::Point, increase x by the
+  # other's x and y by the other's y; 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.get_x, get_y + arg.get_y )
+    when Numeric
+      self.class.new( (get_x + arg).to_i, (get_y + arg).to_i )
+    else
+      Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+    end
+  end
+end

data/lib/wx/classes/previewframe.rb

@@ -0,0 +1,13 @@
+# Frame that displays a print preview
+class Wx::PreviewFrame
+  # a PreviewFrame has a preview associated with it that must be
+  # protected from Ruby's GC. However, there is no C++ method to access
+  # the Wx::PrintPreview (only a protected member), so instead we have
+  # to assign it to an instance variable so it is marked correctly when
+  # the frame displaying it is marked.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    wx_init.bind(self).call(*args)
+    @__preview = args[0]
+  end
+end

data/lib/wx/classes/rect.rb

@@ -0,0 +1,19 @@
+# Class representing a rectangular shape
+class Wx::Rect
+  # Nicely readable inspect output for Rect
+  def to_s
+    "#<Wx::Rect: (#{get_left}, #{get_top}) (#{get_right}, #{get_bottom})>"    
+  end
+
+  # Correct comparison for Wx::Rect, are the same if have the same
+  # position and the same size
+  def ==(other)
+    unless other.kind_of?(Wx::Rect)
+      Kernel.raise TypeError, "Cannot compare Rect to #{other}"
+    end
+    get_left == other.get_left and get_top == other.get_top and
+      get_right = other.get_right and get_bottom == other.get_bottom
+  end
+  # More ruby-ish names
+  alias :contains? :contains
+end

data/lib/wx/classes/richtextctrl.rb

@@ -0,0 +1,63 @@
+# Text editor supporting various formatting, intended for editing
+# natural language texts
+class Wx::RichTextCtrl
+  # These three methods return the styles applicable at certain points
+  # in the document. However, the standard wx signature is to accept the
+  # value of some kind of TextAttr class that will hold the return as an
+  # argument. The return value is a boolean for success/failure. In
+  # Ruby, we only support returning the value as a RichTextAttr, and do
+  # so as a proper return value, having accepted a single argument
+  # specifying where to get the style from. If retrieval is not
+  # successful, raise an exception.
+  wx_get_style = self.instance_method(:get_style)
+  define_method(:get_style) do | pos |
+    style = Wx::RichTextAttr.new
+    if wx_get_style.bind(self).call(pos, style)
+      return style
+    else
+      Kernel.raise RuntimeError, "Could not retrieve style at position #{pos}"
+    end
+  end
+
+  wx_get_style_for_range = self.instance_method(:get_style_for_range)
+  define_method(:get_style_for_range) do | rng |
+    style = Wx::RichTextAttr.new
+    if wx_get_style_for_range.bind(self).call(rng, style)
+      return style
+    else
+      Kernel.raise RuntimeError, "Could not retrieve style for range #{rng}"
+    end
+  end
+
+  wx_get_uncombined_style = self.instance_method(:get_uncombined_style)
+  define_method(:get_uncombined_style) do | pos |
+    style = Wx::RichTextAttr.new
+    if wx_get_uncombined_style.bind(self).call(pos, style)
+      return style
+    else
+      Kernel.raise RuntimeError, "Could not retrieve style at position #{pos}"
+    end
+  end
+
+  # Fix to accept a single +pos+ argument and return a Wx::Rect
+  wx_car_pos_for_index = self.instance_method(:get_caret_position_for_index)
+  define_method(:get_caret_position_for_index) do | pos |
+    rect = Wx::Rect.new
+    if wx_car_pos_for_index.bind(self).call(pos, rect)
+      return rect
+    else
+      Kernel.raise RuntimeError, "Could not rect for position #{pos}"
+    end
+  end
+
+  # Fix to return a pair of col, row values
+  wx_pos_to_xy = self.instance_method(:position_to_xy)
+  define_method(:position_to_xy) do | pos |
+    success, x, y = wx_pos_to_xy.bind(self).call(pos)
+    if success
+      return x, y
+    else
+      Kernel.raise RuntimeError, "Could not convert position #{pos} to x, y"
+    end
+  end
+end