wxruby 1.9.2-i686-darwin8.8.2

data/lib/wx/classes/font.rb

@@ -0,0 +1,118 @@
+class Wx::Font
+  # String names of the constants provided by C++ 
+  # (enum is originally defined inc include/wx/fontenc.h)
+  ENCODING_NAMES = %w[
+    DEFAULT
+
+    ISO-8859-1
+    ISO-8859-2 
+    ISO-8859-3
+    ISO-8859-4
+    ISO-8859-5
+    ISO-8859-6
+    ISO-8859-7
+    ISO-8859-8
+    ISO-8859-9
+    ISO-8859-10
+    ISO-8859-11
+    ISO-8859-12
+    ISO-8859-13
+    ISO-8859-14
+    ISO-8859-15
+    ISO-8859-MAX
+
+    KOI8
+    KOI8-U
+    ALTERNATIVE
+    BULGARIAN
+
+    CP437
+    CP850
+    CP852
+    CP855
+    CP866
+
+    CP874
+    CP932
+    CP936
+    CP949
+    CP950
+    CP1250
+    CP1251
+    CP1252
+    CP1253
+    CP1254
+    CP1255
+    CP1256
+    CP1257
+    CP12-MAX
+
+    UTF7
+    UTF8
+    EUC-JP
+    UTF16BE
+    UTF16LE
+    UTF32BE
+    UTF32LE
+
+    MACROMAN
+    MACJAPANESE
+    MACCHINESETRAD
+    MACKOREAN
+    MACARABIC
+    MACHEBREW
+    MACGREEK
+    MACCYRILLIC
+    MACDEVANAGARI
+    MACGURMUKHI
+    MACGUJARATI
+    MACORIYA
+    MACBENGALI
+    MACTAMIL
+    MACTELUGU
+    MACKANNADA
+    MACMALAJALAM
+    MACSINHALESE
+    MACBURMESE
+    MACKHMER
+    MACTHAI
+    MACLAOTIAN
+    MACGEORGIAN
+    MACARMENIAN
+    MACCHINESESIMP
+    MACTIBETAN
+    MACMONGOLIAN
+    MACETHIOPIC
+    MACCENTRALEUR
+    MACVIATNAMESE
+    MACARABICEXT
+    MACSYMBOL
+    MACDINGBATS
+    MACTURKISH
+    MACCROATIAN
+    MACICELANDIC
+    MACROMANIAN
+    MACCELTIC
+    MACGAELIC
+    MACKEYBOARD
+    MAX
+  ]
+
+  class << self
+    # Returns the name of the platform's default font encoding 
+    def get_default_encoding_name
+      ENCODING_NAMES[ get_default_encoding ]
+    end
+
+    # Sets the default encoding to be +enc+, which may be the string
+    # name of an encoding (eg 'UTF8') or an internal WxWidgets flag 
+    # (eg Wx::FONTENCODING_UTF8).
+    def set_default_encoding_name(enc)
+      if flag_int = ENCODING_NAMES.index(enc.upcase)
+        set_default_encoding(flag_int)
+      else
+        raise ArgumentError, "Unknown font encoding name '#{enc}'"
+      end
+    end
+  end
+end

data/lib/wx/classes/grid.rb

@@ -0,0 +1,130 @@
+# A data-oriented editable table control.
+class Wx::Grid
+  # The following extensions are all to prevent crashes associated with
+  # garbage collection of Grid-related classes; they do not extend the
+  # public functionality of the class in any way. 
+  # 
+  # The GridCellRenderers and GridCellEditors pose a problem for ruby's
+  # GC, in that Wx makes them owned by the grid once they have been set
+  # for a cell or group of cells. However, because they are SWIG
+  # directors we cannot allow the ruby object they are originally
+  # associated with to be swept by GC.
+  #
+  # The code below stores Ruby redefines all methods that may
+  # potentially set an Editor or Renderer, and stores a reference to
+  # it in an instance variable, so they are not disposed of up when GC sweeps.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    wx_init.bind(self).call(*args)
+    @__default_editor   = nil
+    @__default_renderer = nil
+
+    @__cell_editors   = []
+    @__cell_renderers = []
+
+    @__col_renderers = []
+    @__col_editors   = []
+    @__row_renderers = []
+    @__row_editors   = []
+  end
+  
+  # store default editor
+  wx_set_default_editor = self.instance_method(:set_default_editor)
+  define_method(:set_default_editor) do | editr |
+    wx_set_default_editor.bind(self).call(editr)
+    @__default_editor = editr
+  end
+
+  # store default renderer
+  wx_set_default_renderer = self.instance_method(:set_default_renderer)
+  define_method(:set_default_renderer) do | rendr |
+    wx_set_default_renderer.bind(self).call(rendr)
+    @__default_renderer = rendr
+   end
+
+  # store cell editors
+  wx_set_cell_editor = self.instance_method(:set_cell_editor)
+  define_method(:set_cell_editor) do | row, col, editr |
+    wx_set_cell_editor.bind(self).call(row, col, editr)
+    @__cell_editors[row] ||= []
+    @__cell_editors[row][col] = editr
+   end
+
+  # store cell renderer
+  wx_set_cell_renderer = self.instance_method(:set_cell_renderer)
+  define_method(:set_cell_renderer) do | row, col, rendr |
+    wx_set_cell_renderer.bind(self).call(row, col, rendr)
+    @__cell_renderers[row] ||= []
+    @__cell_renderers[row][col] = rendr
+  end
+
+  wx_set_col_attr = self.instance_method(:set_col_attr)
+  define_method(:set_col_attr) do | col, attr |
+    wx_set_col_attr.bind(self).call(col, attr)
+    if attr.has_editor
+      @__col_editors[col] = attr.get_editor(self, 0, col)
+    end
+    if attr.has_renderer
+      @__col_renderers[col] = attr.get_renderer(self, 0, col)
+    end
+  end  
+
+  wx_set_row_attr = self.instance_method(:set_row_attr)
+  define_method(:set_row_attr) do | row, attr |
+    wx_set_row_attr.bind(self).call(row, attr)
+    if attr.has_editor
+      @__row_editors[row] = attr.get_editor(self, row, 0)
+    end
+
+    if attr.has_renderer
+      @__row_renderers[row] = attr.get_renderer(self, row, 0)
+    end
+  end  
+
+  # This and the following methods do a bit of book-keeping - as rows
+  # and columns are deleted and inserted, the position of the columns
+  # and rows with stored editors and renderers may move.
+  alias :__insert_rows :insert_rows
+  def insert_rows(pos = 0, num = 1, update_labels = true)
+    __insert_rows(pos, num, update_labels)
+    num.times { @__row_editors.insert(pos, nil) }
+    num.times { @__row_renderers.insert(pos, nil) }
+    num.times { @__cell_editors.insert(pos, []) }
+    num.times { @__cell_renderers.insert(pos, []) }
+  end
+  
+  alias :__insert_cols :insert_cols
+  def insert_cols(pos = 0, num = 1, update_labels = true)
+    __insert_cols(pos, num, update_labels)
+    num.times { @__col_editors.insert(pos, nil) }
+    num.times { @__col_renderers.insert(pos, nil) }
+    num.times do
+      @__cell_editors.map { | col | col.insert(pos, []) if col }
+    end
+    num.times do
+      @__cell_renderers.map { | col | col.insert(pos, []) if col }
+    end
+  end
+
+  alias :__delete_rows :delete_rows
+  def delete_rows(pos = 0, num = 1, update_labels = true)
+    __delete_rows(pos, num, update_labels)
+    @__row_editors.slice!(pos, num)
+    @__row_renderers.slice!(pos, num)
+    @__cell_editors.slice!(pos, num)
+    @__cell_renderers.slice!(pos, num)
+  end
+ 
+  alias :__delete_cols :delete_cols
+  def delete_cols(pos = 0, num = 1, update_labels = true)
+    __delete_cols(pos, num, update_labels)
+    @__col_editors.slice!(pos, num)
+    @__col_renderers.slice!(pos, num)
+    num.times do
+      @__cell_editors.map { | col | col.slice!(pos, num) if col }
+    end
+    num.times do
+      @__cell_renderers.map { | col | col.slice!(pos, num) if col }
+    end
+  end
+end

data/lib/wx/classes/helpcontroller.rb

@@ -0,0 +1,5 @@
+class Wx::HelpController
+  def self.instance(*args)
+    @instance ||= new(*args)
+  end
+end

data/lib/wx/classes/htmlhelpcontroller.rb

@@ -0,0 +1,5 @@
+class Wx::HtmlHelpController
+  def self.instance(*args)
+    @instance ||= new(*args)
+  end
+end

data/lib/wx/classes/htmlwindow.rb

@@ -0,0 +1,6 @@
+class Wx::HtmlWindow
+  # imitate the in-built LoadFile method
+  def load_file(file)
+    set_page( File.read(file) )
+  end
+end

data/lib/wx/classes/icon.rb

@@ -0,0 +1,14 @@
+class Wx::Icon
+  # 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 later
+  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, "Icon file does not exist: #{args[0]}")
+      end
+    end
+    wx_init.bind(self).call(*args)
+  end
+end

data/lib/wx/classes/image.rb

@@ -0,0 +1,14 @@
+class Wx::Image
+  # 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
+  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
+    end
+    wx_init.bind(self).call(*args)
+  end
+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,9 @@
+# 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
+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/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 : old_meth.bind(self).call(*args)
+            when String : old_meth.bind(self).call(Wx::ID_ANY, *args)
+            when Wx::MenuItem : 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 : old_meth.bind(self).call(pos, *args)
+            when String : old_meth.bind(self).call(pos, Wx::ID_ANY, *args)
+            when Wx::MenuItem : 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/object.rb

@@ -0,0 +1,7 @@
+# The root class for most (not all) WxRuby classes
+class Wx::Object
+  # massage the output of inspect to show the public module name (Wx)
+  def to_s
+    super.sub('ruby2', '')
+  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,48 @@
+class Wx::Point
+  # More informative output when converted to string
+  def to_s
+    "#<Wx::Point: (#{x}, #{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