wxruby 1.9.0-powerpc-darwin8.10.0 → 1.9.2-powerpc-darwin8.10.0

data/lib/wx/classes/checklistbox.rb

@@ -0,0 +1,30 @@
+# Display a listbox with a checkbox for each item
+class Wx::CheckListBox < Wx::ListBox
+
+  # According to the wxWidgets documentation: "wxCheckListBox uses
+  # client data in its implementation, and therefore this is not
+  # available to the application."   
+  #
+  # So, rather than crashing, raise an Exception if this is attempted
+  def append(*args)
+    if args.length == 2 
+      Kernel.raise "Cannot use item data with Wx::CheckListBox"
+    else 
+      super
+    end
+  end
+
+  # As above
+  def insert(*args)
+    if args.length == 3
+      Kernel.raise "Cannot use item data with Wx::CheckListBox"
+    else 
+      super
+    end
+  end
+
+  # As above
+  def set_item_data(index, data)
+    Kernel.raise "Cannot use item data with Wx::CheckListBox"
+  end
+end

data/lib/wx/classes/clientdc.rb

@@ -5,7 +5,7 @@ class Wx::ClientDC
   # 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,
   # avoiding errors and segfaults on exit.
-  def initialize(*args)
+  define_method(:initialize) do | *args |
     Kernel.raise RuntimeError,
                  "Do not instantiate ClientDC directly; use Window#paint",
                  caller[1..-1]

data/lib/wx/classes/commandevent.rb

@@ -0,0 +1,7 @@
+# Class representing interactions with controls such as ListBox
+class Wx::CommandEvent
+  # get_int and get_selection are already synonyms, but neither name
+  # accurately describes what the method does as the event may be a
+  # (de)selection or a check in a CheckListBox
+  alias :get_index :get_int
+end

data/lib/wx/classes/controlwithitems.rb

@@ -0,0 +1,10 @@
+# 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 
+  include Enumerable
+  # Passes each valid item index into the passed block
+  def each
+    0.upto(count - 1) { | i | yield i }
+  end
+end

data/lib/wx/classes/evthandler.rb

@@ -16,14 +16,17 @@ class Wx::EvtHandler
   EventType = Struct.new(:name, :arity, :const, :evt_class)
 
   # Fast look-up hash to map event type ids to ruby event classes
-  EVENT_TYPE_MAPPING = {}
+  EVENT_TYPE_CLASS_MAP = {}
+  # Hash to look up EVT constants from symbol names of evt handler
+  # methods; used internally by disconnect (see EvtHandler.i)
+  EVENT_NAME_TYPE_MAP = {}
 
   # Given a Wx EventType id (eg Wx::EVT_MENU), returns a WxRuby Event
   # class which should be passed to event handler blocks. The actual
   # EVT_XXX constants themselves are in the compiled library, defined in
   # swig/classes/Event.i
   def self.event_class_for_type(id)
-    if evt_klass = EVENT_TYPE_MAPPING[id]
+    if evt_klass = EVENT_TYPE_CLASS_MAP[id]
       return evt_klass
     else
       warn "No event class defined for event type #{id}"
@@ -31,6 +34,19 @@ class Wx::EvtHandler
     end
   end
 
+  # Given the symbol name of an evt_xxx handler method, returns the
+  # Integer Wx::EVT_XXX constant associated with that handler.
+  def self.event_type_for_name(name)
+    EVENT_NAME_TYPE_MAP[name]
+  end
+
+  # Given the Integer constant Wx::EVT_XXX, returns the convenience
+  # handler method name associated with that type of event.
+
+  def self.event_name_for_type(name)
+    EVENT_NAME_TYPE_MAP.index(name)
+  end
+
   # Public method to register the mapping of a custom event type
   # +konstant+ (which should be a unique integer; one will be created if
   # not supplied) to a custom event class +klass+. If +meth+ and +arity+
@@ -48,31 +64,90 @@ class Wx::EvtHandler
   end
 
   # Registers the event type +ev_type+, which should be an instance of
-  # the Struct class +Wx::EvtHandler::EventType+. 
+  # the Struct class +Wx::EvtHandler::EventType+. This sets up the
+  # mapping of events of that type (identified by integer id) to the
+  # appropriate ruby event class, and defines a convenience evt_xxx
+  # instance method in the class EvtHandler.
   def self.register_event_type(ev_type)
-    EVENT_TYPE_MAPPING[ev_type.const] = ev_type.evt_class
+    # set up the event type mapping
+    EVENT_TYPE_CLASS_MAP[ev_type.const] = ev_type.evt_class
+    EVENT_NAME_TYPE_MAP[ev_type.name.intern] = ev_type.const
+
     unless ev_type.arity and ev_type.name
       return 
     end
+
+    # set up the evt_xxx method
     case ev_type.arity
     when 0 # events without an id
       class_eval %Q| 
-        def #{ev_type.name}(&block)
-          connect(Wx::ID_ANY, Wx::ID_ANY, #{ev_type.const}, &block)
+        def #{ev_type.name}(meth = nil, &block)
+          handler = acquire_handler(meth, block)
+          connect(Wx::ID_ANY, Wx::ID_ANY, #{ev_type.const}, &handler)
         end |
     when 1 # events with an id
       class_eval %Q|
-        def #{ev_type.name}(id, &block)
-          connect(id, Wx::ID_ANY, #{ev_type.const}, &block)
+        def #{ev_type.name}(id, meth = nil, &block)
+          handler = acquire_handler(meth, block)
+          id  = acquire_id(id)
+          connect(id, Wx::ID_ANY, #{ev_type.const}, &handler)
         end |
     when 2 # events with id range
       class_eval %Q|
-        def #{ev_type.name}(first_id, last_id, &block)
-          connect(first_id, last_id, #{ev_type.const}, &block)
+        def #{ev_type.name}(first_id, last_id, meth = nil, &block)
+          handler  = acquire_handler(meth, block)
+          first_id = acquire_id(first_id)
+          last_id  = acquire_id(last_id)
+          connect( first_id, last_id, #{ev_type.const}, &handler)
         end |
     end
   end
 
+  # Not for external use; determines whether to use a block or call a
+  # method in self to handle an event, passed to connect. Makes evt_xxx
+  # liberal about what it accepts - aside from a block, it can be a
+  # method name (as Symbol or String), a (bound) method object, or a
+  # Proc object
+  def acquire_handler(meth, block)
+    if block and not meth
+      return block
+    elsif meth and not block
+      h_meth = case meth
+        when Symbol, String : self.method(meth)
+        when Proc : meth
+        when Method : meth.to_proc
+      end
+      if h_meth.arity == 1
+        return lambda { | evt | h_meth.call(evt) }
+      else
+        return lambda { h_meth.call }
+      end
+    else
+      Kernel.raise ArgumentError,
+                  "Specify event handler with a method, name, proc OR block"
+                  caller
+    end
+  end
+
+  # Not for external use; acquires an id either from an explicit Fixnum
+  # parameter or by calling the wx_id method of a passed Window.
+  def acquire_id(window_or_id)
+    case window_or_id
+    when Fixnum : window_or_id
+    when Wx::Window, Wx::MenuItem : window_or_id.wx_id
+    else Kernel.raise ArgumentError, 
+                     "Must specify Wx::Window event source or its Wx id, " +
+                     "not '#{window_or_id.inspect}'",
+                      caller
+    end
+  end
+  private :acquire_id, :acquire_handler
+
+  # Definitions for all event types that are part by core wxRuby. Events
+  # that are mapped to class Wx::Event are TODO as they are not
+  # currently wrapped by the correct class. All StyledTextCtrl
+  # (Scintilla) events with prefix EVT_STC are dealt with in the
+  # separate styledtextctrl.rb file.
   EVENT_DEFINITIONS = [ 
     EventType['evt_activate', 0,
               Wx::EVT_ACTIVATE, 
@@ -173,6 +248,9 @@ class Wx::EvtHandler
     EventType['evt_close', 0,
               Wx::EVT_CLOSE_WINDOW, 
               Wx::CloseEvent],
+    EventType['evt_collapsiblepane_changed', 1,
+              Wx::EVT_COMMAND_COLLPANE_CHANGED, 
+              Wx::CollapsiblePaneEvent],
     EventType['evt_combobox', 1,
               Wx::EVT_COMMAND_COMBOBOX_SELECTED, 
               Wx::CommandEvent],
@@ -791,34 +869,16 @@ class Wx::EvtHandler
     evt_mousewheel(&block)
   end
 
-# TODO
-#   if defined?(Wx::Scintilla)
-#     EVENT_TYPE_MAPPING.merge(
-#       Wx::EVT_SCI_CHANGE => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_STYLENEEDED => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_CHARADDED => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_SAVEPOINTREACHED => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_SAVEPOINTLEFT => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_ROMODIFYATTEMPT => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_KEY => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_DOUBLECLICK => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_UPDATEUI => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_MODIFIED => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_MACRORECORD => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_MARGINCLICK => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_NEEDSHOWN => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_PAINTED => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_USERLISTSELECTION => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_URIDROPPED => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_DWELLSTART => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_DWELLEND => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_START_DRAG => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_DRAG_OVER => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_DO_DROP => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_ZOOM => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_HOTSPOT_CLICK => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_HOTSPOT_DCLICK => Wx::ScintillaEvent,
-#       Wx::EVT_SCI_CALLTIP_CLICK => Wx::ScintillaEvent )
-#   end
+  # convenience evt handler to listen to all scrollwin events
+  def evt_scrollwin(&block)
+    evt_scrollwin_top(&block)
+    evt_scrollwin_bottom(&block)
+    evt_scrollwin_lineup(&block)
+    evt_scrollwin_linedown(&block)
+    evt_scrollwin_pageup(&block)
+    evt_scrollwin_pagedown(&block)
+    evt_scrollwin_thumbtrack(&block)
+    evt_scrollwin_thumbrelease(&block)
+  end
 end
 

data/lib/wx/classes/grid.rb

@@ -84,18 +84,18 @@ class Wx::Grid
   # 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.
-  wx_insert_rows = self.instance_method(:insert_rows)
-  define_method(:insert_rows) do | pos, num |
-    wx_insert_rows.bind(self).call(pos, num)
+  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
-
-  wx_insert_cols = self.instance_method(:insert_cols)
-  define_method(:insert_cols) do | pos, num |
-    wx_insert_cols.bind(self).call(pos, num)
+  
+  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
@@ -106,18 +106,18 @@ class Wx::Grid
     end
   end
 
-  wx_delete_rows = self.instance_method(:delete_rows)
-  define_method(:delete_rows) do | pos, num |
-    wx_delete_rows.bind(self).call(pos, num)
+  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
  
-  wx_delete_cols = self.instance_method(:delete_cols)
-  define_method(:delete_cols) do | pos, num |
-    wx_delete_cols.bind(self).call(pos, num)
+  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

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/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/paintdc.rb

@@ -4,7 +4,7 @@ class Wx::PaintDC
   # 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.
-  def initialize(*args)
+  define_method(:initialize) do | *args |
     Kernel.raise RuntimeError,
                  "Do not instantiate PaintDC directly; use Window#paint",
                  caller[1..-1]

data/lib/wx/classes/point.rb

@@ -1,5 +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

data/lib/wx/classes/size.rb

@@ -2,4 +2,48 @@ class Wx::Size
   def to_s
     "#<Wx::Size: (#{get_width}, #{get_height})>"
   end
+
+  # Return a new Wx::Size with the width and height values 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::Size with the width and height 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::Size with the width and height parameters both
+  # reduced by parameter +arg+. If +arg+ is another Wx::Size, reduce
+  # width by the other's width and height by the other's height; if
+  # +arg+ is a numeric value, reduce both width and height 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::Size with the width and height parameters both
+  # increased by parameter +arg+. If +arg+ is another Wx::Size, increase
+  # width by the other's width and height by the other's height; if
+  # +arg+ is a numeric value, increase both width and height 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