wxruby 1.9.0-i686-darwin8.4.1 → 1.9.1-i686-darwin8.4.1

data/lib/wx/accessors.rb

@@ -0,0 +1,52 @@
+# = WxSugar - Accessors
+#
+# The default WxRuby interface has lots and lots of methods like
+#
+#  * get_position()
+#  * set_size(a_size)
+#  * is_checked()
+# 
+# and so on. Methods that retrieve set, or query attributes of an object
+# are more normally in Ruby called simply by the attribute name:
+#
+#  * position()
+#  * size = a_size
+#  * checked?
+#
+# This extension creates an alias for every WxRuby instance method that
+# begins with +get_+, +set_+ or +is_+. Note that if you are calling a
+# 'setter' method on self, you must explicitly send the message to self:
+# 
+#  # set's self size to be 100px by 100px
+#  self.size = Wx::Size.new(100, 100)
+#  # only sets the value of a local variable 'size'
+#  size = Wx::Size.new
+
+module WxRubyStyleAccessors
+  def method_missing(sym, *args)
+    case sym.to_s
+    when /^(.*)\=$/
+      meth = "set_#{$1}"
+    when /^(.*)\?$/
+      meth = "is_#{$1}"
+    else
+      meth = "get_#{sym}"
+    end
+    if respond_to?(meth)
+      send(meth, *args)
+    else
+      e = NoMethodError.new("undefined method '#{sym}' for #{self.inspect}")
+      e.set_backtrace(caller)
+      Kernel.raise e
+    end
+  end
+end
+
+all_classes = Wx::constants.collect { | c | Wx::const_get(c) }.grep(Class)
+
+all_classes.each do | klass |
+  klass.class_eval do
+    include WxRubyStyleAccessors
+    extend WxRubyStyleAccessors
+  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,18 @@ 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+
@@ -50,7 +65,9 @@ class Wx::EvtHandler
   # Registers the event type +ev_type+, which should be an instance of
   # the Struct class +Wx::EvtHandler::EventType+. 
   def self.register_event_type(ev_type)
-    EVENT_TYPE_MAPPING[ev_type.const] = ev_type.evt_class
+    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
@@ -73,6 +90,11 @@ class Wx::EvtHandler
     end
   end
 
+  # 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, 
@@ -791,34 +813,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/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

data/lib/wx/classes/styledtextctrl.rb

@@ -0,0 +1,92 @@
+# Functionality here must be loaded first to add custom events
+require 'wx/classes/evthandler'
+
+# These event type constants will only be available and meaningful if
+# Wx::StyledTextCtrl has been compiled into the library. If so, they
+# need the below definitions for mapping, otherwise all the rest should
+# be skipped
+if defined?(Wx::StyledTextCtrl)
+  EventType = Wx::EvtHandler::EventType
+
+  STC_EVENT_TYPES = [ 
+    EventType['evt_stc_calltip_click', 1,
+              Wx::EVT_STC_CALLTIP_CLICK, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_change', 1,
+              Wx::EVT_STC_CHANGE, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_charadded', 1,
+              Wx::EVT_STC_CHARADDED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_doubleclick', 1,
+              Wx::EVT_STC_DOUBLECLICK, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_do_drop', 1,
+              Wx::EVT_STC_DO_DROP,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_drag_over', 1,
+              Wx::EVT_STC_DRAG_OVER,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_dwellend', 1,
+              Wx::EVT_STC_DWELLEND,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_dwellstart', 1,
+              Wx::EVT_STC_DWELLSTART,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_hotspot_click', 1,
+              Wx::EVT_STC_HOTSPOT_CLICK,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_hotspot_dclick', 1,
+              Wx::EVT_STC_HOTSPOT_DCLICK,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_key', 1,
+              Wx::EVT_STC_KEY,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_macrorecord', 1,
+              Wx::EVT_STC_MACRORECORD, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_marginclick', 1,
+              Wx::EVT_STC_MARGINCLICK, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_modified', 1,
+              Wx::EVT_STC_MODIFIED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_needshown', 1,
+              Wx::EVT_STC_NEEDSHOWN, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_painted', 1,
+              Wx::EVT_STC_PAINTED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_romodifyattempt', 1,
+              Wx::EVT_STC_ROMODIFYATTEMPT, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_savepointleft', 1,
+              Wx::EVT_STC_SAVEPOINTLEFT, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_savepointreached', 1,
+              Wx::EVT_STC_SAVEPOINTREACHED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_start_drag', 1,
+              Wx::EVT_STC_START_DRAG, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_styleneeded', 1,
+              Wx::EVT_STC_STYLENEEDED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_updateui', 1,
+              Wx::EVT_STC_UPDATEUI, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_uridropped', 1,
+              Wx::EVT_STC_URIDROPPED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_userlistselection', 1,
+              Wx::EVT_STC_USERLISTSELECTION, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_zoom', 1,
+              Wx::EVT_STC_ZOOM, 
+              Wx::StyledTextEvent]
+    ]
+
+  STC_EVENT_TYPES.each do | ev_type | 
+    Wx::EvtHandler.register_event_type(ev_type)
+  end
+end

data/lib/wx/classes/textctrl.rb

@@ -0,0 +1,14 @@
+class Wx::TextCtrl
+  # Fix position_to_xy so it returns a two-element array - the internal
+  # version returns a three-element array with a Boolean that doesn't
+  # really make sense in Ruby
+  wx_position_to_xy = instance_method(:position_to_xy)
+  define_method(:position_to_xy) do | pos |
+    retval, x, y = wx_position_to_xy.bind(self).call(pos)
+    if retval
+      return [x, y]
+    else
+      return nil
+    end
+  end
+end

data/lib/wx/classes/window.rb

@@ -2,6 +2,10 @@
 # released under the MIT-style wxruby2 license
 
 class Wx::Window
+  # Create a wx-specific name for get_id, to prevent confusion with
+  # ruby's (deprecated) Object#id
+  alias :wx_id :get_id
+
   # Recursively searches all windows below +self+ and returns the first
   # window which has the id +an_id+. This corresponds to the find_window
   # method method in WxWidgets when called with an integer.

data/lib/wx/keyword_ctors.rb

@@ -0,0 +1,219 @@
+# = WxRuby Extensions - Keyword Constructors
+# 
+# The *Keyword Constructors* extension allows the use of Ruby hash-style
+# keyword arguments in constructors of common WxWidgets Windows, Frame,
+# Dialog and Control classes.
+# 
+# == Introduction
+#
+# Building a GUI in WxWidgets involves lots of calls to +new+, but
+# these methods often have long parameter lists. Often the default
+# values for many of these parameters are correct. For example, if
+# you're using a sizer-based layout, you usually don't want to specify a
+# size for widgets, but you still have to type
+#  
+#  Wx::TreeCtrl.new( parent, -1, Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE, 
+#                    Wx::NO_BUTTONS )
+#  
+# just to create a standard TreeCtrl with the 'no buttons' style. If you
+# want to specify the 'NO BUTTONS' style, you can't avoid all the typing
+# of DEFAULT_POSITION etc.
+#
+# == Basic Keyword Constructors
+# 
+# With keyword_constructors, you could write the above as
+# 
+#  TreeCtrl.new(parent, :style => Wx::NO_BUTTONS)
+# 
+# And it will assume you want the default id (-1), and the default size
+# and position. If you want to specify an explicit size, you can do so:
+#
+#  TreeCtrl.new(parent, :size => Wx::Size.new(100, 300))
+# 
+# For brevity, this module also allows you to specify positions and
+# sizes using a a two-element array:
+#  
+#  TreeCtrl.new(parent, :size => [100, 300])
+#
+# Similarly with position:
+#
+#  TreeCtrl.new(parent, :pos => Wx::Point.new(5, 25))
+#
+#  TreeCtrl.new(parent, :pos => [5, 25])
+#
+# You can have multiple keyword arguments:
+#
+#  TreeCtrl.new(parent, :pos => [5, 25], :size => [100, 300] )
+#
+# == No ID required
+# 
+# As with position and size, you usually don't want to deal with
+# assigning unique ids to every widget and frame you create - it's a C++
+# hangover that often seems clunky in Ruby. The *Event Connectors*
+# extension allows you to set up event handling without having to use
+# ids, and if no :id argument is supplied to a constructor, the default
+# (-1) will be passed.
+#
+# There are occasions when a specific ID does need to be used - for
+# example, to tell WxWidgets that a button is a 'stock' item, so that it
+# can be displayed using platform-standard text and icon. To do this,
+# simply pass an :id argument to the constructor - here, the system's
+# standard 'preview' button
+#
+#  Wx::Button.new(parent, :id => Wx::ID_PREVIEW) 
+#
+# == Class-specific arguments
+# 
+# The arguments :size, :pos and :style are common to many WxWidgets
+# window classes. The +new+ methods of these classes also have
+# parameters that are specific to those classes; for example, the text
+# label on a button, or the initial value of a text control.
+# 
+#  Wx::Button.new(parent, :label => 'press me')
+#  Wx::TextCtrl.new(parent, :value => 'type some text here')
+#
+# The keyword names of these arguments can be found by looking at the
+# WxRuby documentation, in the relevant class's +new+ method. You can
+# also get a string description of the class's +new+ method parameters
+# within Ruby by doing:
+# 
+#  puts Wx::TextCtrl.describe_constructor()
+# 
+# This will print a list of the argument names expected by the class's
+# +new+ method, and the correct type for them.
+#
+# == Mixing positional and keyword arguments
+#
+# To support existing code, and to avoid forcing the use of more verbose
+# keyword-style arguments where they're not desired, you can mix
+# positional and keyword arguments, omitting or including +id+s as
+# desired.
+#
+#  Wx::Button.new(parent, 'press me', :style => Wx::BU_RIGHT)
+
+module Wx
+  module KeywordConstructor
+    module ClassMethods
+
+      # Common Wx constructor argument keywords, with their default values.
+      STANDARD_DEFAULTS = {
+        :id        => -1,
+        :size      => Wx::DEFAULT_SIZE,
+        :pos       => Wx::DEFAULT_POSITION,
+        :style     => 0,
+        :validator => Wx::DEFAULT_VALIDATOR,
+        :choices   => [] # for Choice, ComboBox etc
+      }
+
+      
+      # A named parameter in a Wx constructor parameter list
+      Parameter = Struct.new( :name, :default )
+
+      attr_writer :param_spec
+      def param_spec
+        @param_spec ||= []
+      end
+
+      attr_writer :param_flags
+      def param_flags
+        @param_flags ||= {}
+      end
+
+      
+      # Adds a list of named parameters *params* to the parameter
+      # specification for this Wx class's constructor. Each parameter
+      # should be specified as a either a common known symbol, such as
+      # +:size+ or +:pos:+ or +:style:+ (corresponding to the common
+      # constructor arguments in WxWidgets API), or a single-key with the
+      # key the name of the argument, and the value a default value.
+      # 
+      # Parameters should be specified in the order they occur in the Wx
+      # API constructor
+      def wx_ctor_params(*params)
+        self.param_spec += params.map do | param |
+          param.kind_of?(Hash) ? Parameter[*param.to_a.flatten] : 
+            Parameter[param, STANDARD_DEFAULTS[param] ]
+        end
+      end
+
+      def args_as_list(*mixed_args)
+        # get keyword arguments from mixed args if supplied, else empty
+        kwa = mixed_args.last.kind_of?(Hash) ? mixed_args.pop : {}
+        out_args = []
+        param_spec.zip(mixed_args) do | param, arg |
+          if arg # use the supplied list arg 
+            out_args << arg
+          elsif kwa.key?(param.name) # use the keyword arg
+            out_args << kwa[param.name]
+          else # use the default argument
+            out_args << param.default
+          end
+        end
+        out_args
+      rescue
+        Kernel.raise ArgumentError, 
+                     "Bad arg composition of #{mixed_args.inspect}"
+      end
+
+      def args_as_hash(*mixed_args)
+        kwa = mixed_args.last.kind_of?(Hash) ? mixed_args.pop : {}
+        param_spec.zip(mixed_args) do | param, arg |
+          kwa[param.name] = arg if arg
+        end
+        kwa 
+      end
+      
+      def describe_constructor()
+        param_spec.inject("") do | desc, param |
+          desc << "#{param.name} (#{param.default.class.name})\n"
+        end
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.module_eval do
+
+        alias :pre_wx_kwctor_init :initialize
+
+        def initialize(parent = :default_ctor, *mixed_args)
+          # allow zero-args ctor for use with XRC
+          if parent == :default_ctor
+            pre_wx_kwctor_init()
+            return
+          end
+
+          # Allow classes to ignore :id argument in positional args
+          unless self.class < Wx::Dialog
+            if not mixed_args[0].kind_of?(Fixnum)
+              mixed_args.unshift(-1) 
+            end
+          end
+
+          real_args = [ parent ] + self.class.args_as_list(*mixed_args)
+          begin
+            pre_wx_kwctor_init(*real_args)
+          rescue
+            msg = "Error initializing #{self.inspect} \n" +
+                  "Sent parameters: #{real_args.inspect}\n" +
+                   "Correct parameters are:\n" + 
+                   self.class.describe_constructor()
+            Kernel.raise ArgumentError, msg
+          end
+          
+          yield self if block_given?
+        end
+      end
+      
+      # Any class inheriting from a class including this module must have
+      # its own copy of the param_spec
+      def klass.inherited(sub_klass)
+        sub_klass.instance_variable_set(:@param_spec, 
+                                        instance_variable_get(:@param_spec) )
+        sub_klass.instance_variable_set(:@param_flags, 
+                                        instance_variable_get(:@param_flags) )
+      end
+    end
+  end
+end
+