fxruby 1.6.20-x86-linux

data/rdoc-sources/FXWizard.rb

@@ -0,0 +1,59 @@
+module Fox
+  #
+  # An FXWizard widget guides the user through a number of panels
+  # in a predefined sequence; each step must be completed before
+  # moving on to the next step.
+  # For example, an FXWizard may be used to install software components,
+  # and ask various questions at each step in the installation.
+  #
+  # === Message identifiers
+  #
+  # +ID_NEXT+::		Move to the next panel in the wizard
+  # +ID_BACK+::		Move to the previous panel in the wizard
+  #
+  class FXWizard < FXDialogBox
+  
+    # The button frame [FXHorizontalFrame]
+    attr_reader :buttonFrame
+    
+    # The "Advance" button [FXButton]
+    attr_reader :advanceButton
+    
+    # The "Retreat" button [FXButton]
+    attr_reader :retreatButton
+    
+    # The "Finish" button [FXButton]
+    attr_reader :finishButton
+    
+    # The "Cancel" button [FXButton]
+    attr_reader :cancelButton
+    
+    # The container used as parent for the sub-panels [FXSwitcher]
+    attr_reader :container
+    
+    # The image being displayed [FXImage]
+    attr_accessor :image
+    
+    #
+    # Return an initialized FXWizard instance.
+    # If _owner_ is a window, the dialog box will float over that window.
+    # If _owner_ is the application, the dialog box will be free-floating.
+    #
+    def initialize(owner, name, image, opts=DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE, x=0, y=0, width=0, height=0, padLeft=10, padRight=10, padTop=10, padBottom=10, hSpacing=10, vSpacing=10) # :yields: theWizard
+    end
+
+    # Return the number of panels.
+    def numPanels; end
+
+    #
+    # Bring the child window at _index_ to the top.
+    # Raises IndexError if _index_ is out of bounds.
+    #
+    def currentPanel=(index); end
+
+    #
+    # Return the index of the child window currently on top.
+    #
+    def currentPanel; end
+  end
+end

data/rdoc-sources/FXXBMIcon.rb

@@ -0,0 +1,37 @@
+module Fox
+  #
+  # X Bitmap (XBM) Icon
+  #
+  class FXXBMIcon < FXIcon
+    #
+    # Return the suggested file extension for this image type ("xbm").
+    #
+    def FXXBMIcon.fileExt; end
+    
+    #
+    # Return the MIME type for this image type
+    #
+    def FXXBMIcon.mimeType; end
+
+    #
+    # Return an initialized FXXBMIcon instance.
+    #
+    # ==== Parameters:
+    #
+    # +a+::		an application instance [FXApp]
+    # +pixels+::	a memory buffer formatted in XBM file format [String]
+    # +mask+::		a memory buffer formatted in XBM file format [String]
+    # +clr+::		transparency color [FXColor]
+    # +opts+::		options [Integer]
+    # +width+::		width [Integer]
+    # +height+::		height [Integer]
+    #
+    def initialize(a, pixels=nil, mask=nil, clr=0, opts=0, width=1, height=1) # :yields: theXBMIcon
+    end
+  end
+  
+  #
+  # Return +true+ if _store_ (an FXStream instance) contains an XBM image.
+  #
+  def Fox.fxcheckXBM(store); end
+end

data/rdoc-sources/FXXBMImage.rb

@@ -0,0 +1,32 @@
+module Fox
+  #
+  # X Bitmap (XBM) image
+  #
+  class FXXBMImage < FXImage
+    #
+    # Return the suggested file extension for this image type ("xbm").
+    #
+    def FXXBMImage.fileExt; end
+    
+    #
+    # Return the MIME type for this image type
+    #
+    def FXXBMImage.mimeType; end
+
+    #
+    # Return an initialized FXXBMImage instance.
+    #
+    # ==== Parameters:
+    #
+    # +a+::		an application instance [FXApp]
+    # +pixels+::	a memory buffer formatted in XBM file format [String]
+    # +mask+::		a memory buffer formatted in XBM file format [String]
+    # +opts+::		options [Integer]
+    # +width+::		width [Integer]
+    # +height+::		height [Integer]
+    #
+    def initialize(a, pixels=nil, mask=nil, opts=0, width=1, height=1) # :yields: theXBMImage
+    end
+  end
+end
+

data/rdoc-sources/FXXPMIcon.rb

@@ -0,0 +1,65 @@
+module Fox
+  #
+  # X Pixmap (XPM) Icon
+  #
+  class FXXPMIcon < FXIcon
+    #
+    # Return the suggested file extension for this image type ("xpm").
+    #
+    def FXXPMIcon.fileExt; end
+
+    #
+    # Return the MIME type for this image type
+    #
+    def FXXPMIcon.mimeType; end
+
+    #
+    # Return an initialized FXXPMIcon instance.
+    #
+    # ==== Parameters:
+    #
+    # +a+::	an application instance [FXApp]
+    # +pix+::	a memory buffer formatted in XPM file format [String]
+    # +clr+::	transparency color [FXColor]
+    # +opts+::	options [Integer]
+    # +width+::	width [Integer]
+    # +height+::	height [Integer]
+    #
+    def initialize(a, pix=nil, clr=0, opts=0, width=1, height=1) # :yields: theXPMIcon
+    end
+  end
+  
+  #
+  # Load a XPM file from a stream.
+  # If successful, returns an array containing the image pixel data (as an
+  # array of FXColor values), the transparency color (another FXColor) and the
+  # image width and the image height.
+  # If it fails, the function returns +nil+.
+  #
+  # ==== Parameters:
+  #
+  # +store+::	stream from which to read the file data [FXStream]
+  #
+  def Fox.fxloadXPM(store); end
+
+  #
+  # Save an XPM image to _store_ (an FXStream instance).
+  # Returns +true+ on success, +false+ on failure.
+  #
+  # ==== Parameters:
+  #
+  # +store+::	stream to which to write the file data [FXStream]
+  # +data+::	the image pixel data, an array of FXColor values
+  # +transp+::	transparency color [FXColor]
+  # +width+::	width [Integer]
+  # +height+::	height [Integer]
+  # +fast+::	if +true+, use fast something
+  #
+  def fxsaveXPM(store, data, transp, width, height, fast=true); end
+  
+  #
+  # Return +true+ if _store_ (an FXStream instance) contains an XPM image.
+  #
+  def Fox.fxcheckXPM(store); end
+end
+

data/rdoc-sources/FXXPMImage.rb

@@ -0,0 +1,31 @@
+module Fox
+  #
+  # X Pixmap (XPM) Image
+  #
+  class FXXPMImage < FXImage
+    #
+    # Return the suggested file extension for this image type ("xpm").
+    #
+    def FXXPMImage.fileExt; end
+    
+    #
+    # Return the MIME type for this image type
+    #
+    def FXXPMImage.mimeType; end
+
+    #
+    # Return an initialized FXXPMImage instance.
+    #
+    # ==== Parameters:
+    #
+    # +a+::	an application instance [FXApp]
+    # +pix+::	a memory buffer formatted in XPM file format [String]
+    # +opts+::	options [Integer]
+    # +width+::	width [Integer]
+    # +height+::	height [Integer]
+    #
+    def initialize(a, pix=nil, opts=0, width=1, height=1) # :yields: theXPMImage
+    end
+  end
+end
+

data/rdoc-sources/Makefile

@@ -0,0 +1,23 @@
+SOURCES = *.rb \
+        ../lib/fox/calendar.rb \
+        ../lib/fox/chore.rb \
+        ../lib/fox/core.rb \
+        ../lib/fox/glgroup.rb \
+        ../lib/fox/glshapes.rb \
+        ../lib/fox/input.rb \
+        ../lib/fox/iterators.rb \
+        ../lib/fox/responder2.rb \
+        ../lib/fox/scintilla.rb \
+        ../lib/fox/signal.rb \
+        ../lib/fox/timeout.rb \
+        ../lib/fox/undolist.rb \
+        ../lib/fox/version.rb
+
+rdoc:
+	@rdoc --op ../doc/api --main README.rdoc $(SOURCES) README.rdoc
+
+ri:
+	@rdoc --ri $(SOURCES)
+
+clean:
+	@rm -rf ../doc/api

data/rdoc-sources/README.rdoc

@@ -0,0 +1,53 @@
+= Introduction
+
+<b>This is the RDoc-generated API documentation for FXRuby version 1.6.</b>
+If you have some constructive comments about the content, format or
+presentation, please do send those to me (at mailto:lyle@rubyforge.org).
+
+= Page layout
+
+The page layout is roughly the same for every class. The page begins
+with a brief description of the class and is then followed by one or
+more of the following sections:
+
+[*Attributes*]
+  This section lists the names of all the attributes for this widget.
+  As with all Ruby object "attributes", these are actually just the names
+  of instance methods for the class, but it is nevertheless natural to think
+  of these as attributes (or _properties_) of the widget. Most attributes
+  are both readable and writeable, but some are only read-only, so be sure
+  to check the attributes listing within the main class documentation section
+  to be sure.
+[*Events*]
+  This section lists the types for all of the messages that this widget
+  might send to its message target, and the circumstances under which those
+  messages are sent. When it's important, the message data associated with
+  that event is also described.
+[*Options*]
+  Most widgets have one or more options that affect their appearance or
+  behavior. These options can be passed into the class's _new_
+  method when the object is first instantiated. They can usually also be
+  changed after the object exists via some object-specific accessor method.
+  For example, the options for an FXButton can be get or set via the
+  FXButton#buttonStyle accessor methods.
+
+= Where's the code?
+
+One difference you may notice from documentation generated for other
+Ruby extensions is that there's no source code attached to the instance
+methods when you click on them (i.e. they will appear to be empty
+method definitions). That's because most of these functions are in fact
+implemented in C++ code (since FXRuby is itself a C++ extension to Ruby).
+
+= TODO
+
+A few notes and suggestions from Hugh Sasse:
+
+* It may help to add information about what happens when block_given?()
+  is true or false, i.e. does this affect the return value for a method?
+* In lieu of (or in addition) to short code examples embedded in the API
+  documentation, links to examples that are shipped with FXRuby might be good.
+----
+
+The HTML pages for this documentation were generated using RDoc
+(http://rdoc.sourceforge.net). 

data/rdoc-sources/fxdefs.rb

@@ -0,0 +1,90 @@
+module Fox
+  # Make an unsigned int out of two unsigned shorts
+  def Fox.MKUINT(lo, hi); end
+  
+  # Return the message type for a selector
+  def Fox.FXSELTYPE(sel); end
+  
+  # Return the message identifier for a selector
+  def Fox.FXSELID(sel); end
+  
+  # Construct an FXColor value from its red, green and blue components
+  def Fox.FXRGB(r, g, b); end
+  
+  # Construct an FXColor value from its red, green, blue and alpha (transparency) components
+  def Fox.FXRGBA(r, g, b, a); end
+  
+  # Return the red value from an FXColor value
+  def Fox.FXREDVAL(color); end
+  
+  # Return the red value from an FXColor value
+  def Fox.FXGREENVAL(color); end
+
+  # Return the red value from an FXColor value
+  def Fox.FXBLUEVAL(color); end
+
+  # Return the red value from an FXColor value
+  def Fox.FXALPHAVAL(color); end
+
+  #
+  # Return the specified component value for this FXColor value,
+  # where _component_ is either 0, 1, 2 or 3.
+  #
+  def Fox.FXRGBACOMPVAL(color, component); end
+
+  #
+  # Return a "hot key" code value that represents the accelerator key
+  # described in the string _str_. The string can contain some combination
+  # of the modifiers _Ctrl_, _Alt_ and _Shift_, plus the key of interest.
+  # For example, to get the accelerator key for Ctrl+Alt+F7, you'd use:
+  #
+  #   hotKey = fxparseAccel("Ctrl+Alt+F7")
+  #
+  def Fox.fxparseAccel(str); end
+  
+  #
+  # Return a hot key value that represents the hot key described in
+  # the string _str_. This method is less flexible than the similar
+  # Fox.fxparseAccel, and is mainly used internally for parsing the
+  # labels for FXButton and FXMenuCommand widgets. For example, this:
+  #
+  #   fxparseHotKey("&File")
+  #
+  # returns the equivalent of:
+  #
+  #   fxparseAccel("Alt+F")
+  #
+  def Fox.fxparseHotKey(s); end
+  
+  # Locate hot key underline offset from begin of string
+  def Fox.fxfindhotkeyoffset(s); end
+  
+  # Get highlight color
+  def Fox.makeHiliteColor(clr); end
+  
+  # Get shadow color
+  def Fox.makeShadowColor(clr); end
+  
+  #
+  # Return the RGB value for this color name.
+  #
+  def Fox.fxcolorfromname(colorName); end
+  
+  #
+  # Return the name of the closest color to the input RGB value.
+  #
+  def Fox.fxnamefromcolor(color); end
+  
+  # Convert RGB to HSV
+  def Fox.fxrgb_to_hsv(r, g, b); end
+  
+  # Convert HSV to RGB
+  def Fox.fxhsv_to_rgb(h, s, v); end
+  
+  # Return the version number that the FOX library has been compiled with, as a String (e.g. "1.0.34"). 
+  def Fox.fxversion(); end
+  
+  # Controls tracing level
+  def Fox.fxTraceLevel; end
+end
+

data/scripts/build-fox.rb

@@ -0,0 +1,31 @@
+#!/usr/local/bin/ruby
+
+def build_project(topdir, project)
+  dspfile = [topdir, 'windows', 'vcpp', project, project + '.dsp'].join(File::ALT_SEPARATOR)
+
+  # Modify the project file to compile-in support for non-native
+  # image file formats
+  bytes = nil
+  File.open(dspfile, 'rb') { |f| bytes = f.read }
+  bytes.sub!('/D "HAVE_GL_H" /D "HAVE_GLU_H"',
+             '/D "HAVE_GL_H" /D "HAVE_GLU_H" /D "HAVE_JPEG_H" /D "HAVE_PNG_H" /D "HAVE_TIFF_H"')
+  bytes.sub!('glu32.lib',
+             'glu32.lib libpng.lib zlib.lib libjpeg.lib libtiff.lib')
+  File.open(dspfile, 'wb') { |f| f.write(bytes) }
+
+  # Build the library
+  system("msdev #{dspfile} /make \"#{project} - Win32 Release\"")
+end
+
+if __FILE__ == $0
+  if ARGV.length != 1
+    puts 'Usage: build-fox [fox-src-dir]'
+    exit
+  end
+
+  topdir = ARGV[0]
+  puts "Building library in #{topdir}..."
+
+  build_project(topdir, 'fox')
+# build_project(topdir, 'foxdll')
+end

data/scripts/generate_kwargs_lib.rb

@@ -0,0 +1,414 @@
+=begin
+Generate replacement initialize() methods that use keyword-argument style
+hash arguments instead of positional arguments.
+
+Known problems (due to overloaded constructors):
+
+* FXCursor
+* FXQuat{d,f}
+* FXRange{d,f}
+* FXRecentFiles
+* FXRectangle
+* FXSphere{d,f}
+
+=end
+
+CLASSES_TO_SKIP = %w{FX4Splitter FXCursor FXDCWindow FXExtentd FXExtentf FXFont FXGLCanvas FXGLShape FXGLViewer FXDockBar FXMenuBar FXToolBar FXQuatd FXQuatf FXRanged FXRangef FXRecentFiles FXRectangle FXRegion FXSize FXSphered FXSpheref FXSplitter FXVec2d FXVec2f FXVec3d FXVec3f FXVec4d FXVec4f FXWindow}
+
+class Arg
+  attr_reader :name
+  attr_reader :value
+
+  def initialize(name, value)
+    @name = name
+    @value = value
+  end
+end
+
+class MethodDescription
+  attr_accessor :method_name
+  attr_accessor :required_args
+  attr_accessor :optional_args
+
+  def initialize
+    @method_name = nil
+    @required_args = []
+    @optional_args = []
+  end
+  
+  def generate_alias
+    "    alias old_#{method_name} #{method_name}\n"
+  end
+  
+  def generate_body
+    argument_names = optional_args.map { |arg| arg.name }
+    defaults_hash = optional_args.map { |arg| ":#{arg.name} => #{arg.value}"}
+    defaults_hash = "{ #{defaults_hash.join(', ')} }"
+    required = required_args.join(", ")
+    optional = optional_args.map { |arg| "params[:#{arg.name}]"}
+    optional = optional.join(", ")
+    buffer = ""
+    buffer << "    def #{method_name}(#{required}#{required_args.length > 0 ? ', ' : ''}*args#{expects_block? ? ', &blk' : ''})\n"
+    buffer << "      argument_names = %w{#{argument_names.join(' ')}}\n"
+    buffer << "      default_params = #{defaults_hash}\n"
+    buffer << "      params = {}\n"
+    buffer << "      params = args.pop if args.last.is_a? Hash\n"
+    buffer << "      args.each_with_index { |e, i| params[argument_names[i].intern] = e }\n"
+    if optional_args.any? { |arg| arg.name == "padLeft" }
+      buffer << "      if params.key? :padding\n"
+      buffer << "        value = params.delete(:padding)\n"
+      buffer << "        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }\n"
+      buffer << "      end\n"
+    end
+    buffer << "      params.keys.each { |key| raise ArgumentError, \"Unrecognized parameter \#{key}\" unless default_params.keys.include?(key) }\n"
+    buffer << "      params = default_params.merge(params)\n"
+    buffer << "      old_#{method_name}(#{required}#{(required_args.length > 0) && (optional_args.length > 0) ? ', ' : ''}#{optional}#{expects_block? ? ', &blk' : ''})\n"
+    buffer << "    end\n"
+    buffer
+  end
+  
+  def expects_block?
+    method_name == "initialize"
+  end
+end
+
+class ClassDescription  
+  attr_accessor :class_name
+  attr_accessor :method_descriptions
+  
+  def initialize
+    @class_name = nil
+    @method_descriptions = []
+  end
+  
+  def generate_class_initializer
+    buffer = ""
+    buffer << "  class #{class_name}\n"
+    method_descriptions.each do |method_description|
+      buffer << method_description.generate_alias
+      buffer << method_description.generate_body
+    end
+    buffer << "  end\n\n"
+    buffer
+  end
+  
+  def has_methods_with_optional_arguments?
+    method_descriptions.each do |m|
+      return true if m.optional_args.length > 0
+    end
+    false
+  end
+end
+
+class Generator
+
+  def initialize
+    @known_classes = {}
+  end
+
+  def generate_preamble(out)
+    out.puts <<-END
+require 'fox16'
+
+$VERBOSE = nil
+
+module Fox
+
+END
+    out.puts(DATA.read)
+  end
+
+  def go(filenames, output_filename)
+    out = File.new(output_filename, "w")
+    class_descriptions = []
+    filenames.each { |filename| class_descriptions += scan_for_descriptions(filename) }
+    generate_preamble(out)
+    class_descriptions.each do |class_description|
+      out.puts class_description.generate_class_initializer if class_description.has_methods_with_optional_arguments?
+    end
+    generate_closing(out)
+  end
+  
+  def generate_closing(out)
+    out.puts "end"
+    out.puts ""
+    out.puts "$VERBOSE = true"
+  end
+  
+  def scan_for_descriptions(filename)
+    class_description = nil
+    class_descriptions = []
+    IO.foreach(filename) do |str|
+      if str =~ /^  class\s*(\w+).*$/
+        class_description = ClassDescription.new
+        class_description.class_name = $1
+      elsif str =~ /def (initialize|findText)\((.*)\)/
+        method_description = MethodDescription.new
+        method_description.method_name = $1
+#       args = $2.split(',').map { |x| x.strip }
+        args = $2.split(', ').map { |x| x.strip }
+        args.each do |arg|
+          if arg =~ /(.*)=(.*)/
+            method_description.optional_args << Arg.new($1, $2)
+          elsif
+            method_description.required_args << arg
+          end
+        end
+        if @known_classes.has_key? class_description.class_name
+          warn "Overloaded initialize method for class: #{class_description.class_name}"
+        end
+        @known_classes[class_description.class_name] = 1
+        class_description.method_descriptions << method_description
+      elsif str =~ /^  end/
+        class_descriptions << class_description unless skip?(class_description.class_name)
+        class_description = nil
+      end
+    end
+    class_descriptions
+  end
+  
+  def skip?(name)
+    CLASSES_TO_SKIP.include? name
+  end
+
+end
+
+if __FILE__ == $0
+  Generator.new.go(Dir.glob('rdoc-sources/*.rb'), 'lib/fox16/kwargs.rb')
+end
+
+__END__
+
+  class FX4Splitter
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => FOURSPLITTER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }     
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args.first.nil? || args.first.is_a?(FXObject))
+        tgt, sel = args[0], args[1]
+        args.each_with_index { |e, i| params[argument_names[i-2].intern] = e if i >= 2 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, tgt, sel, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+
+  class FXDockBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }     
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args.first.nil? || args.first.is_a?(FXComposite))
+        q = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      end
+    end
+  end
+  
+  class FXFont
+
+    alias old_initialize initialize
+    
+    def initialize(a, arg1, *args, &blk)
+      if args.length > 0
+        face, size = arg1, args[0]
+        argument_names = %w{weight slant encoding setWidth hints}
+        default_params = { :weight => FXFont::Normal, :slant => FXFont::Straight, :encoding => FONTENCODING_DEFAULT, :setWidth => FXFont::NonExpanded, :hints => 0 }     
+        params = {}
+        params = args.pop if args.last.is_a? Hash
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(a, face, size, params[:weight], params[:slant], params[:encoding], params[:setWidth], params[:hints], &blk)
+      else
+        old_initialize(a, arg1, &blk)
+      end
+    end
+
+    class << self
+      alias old_listFonts listFonts
+    end
+    
+    def FXFont.listFonts(face, *args)
+      argument_names = %w{weight slant setWidth encoding hints}
+      default_params = { :weight => 0, :slant => 0, :setWidth => 0, :encoding => 0, :hints => 0 }     
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_listFonts(face, params[:weight], params[:slant], params[:setWidth], params[:encoding], params[:hints])
+    end
+
+  end
+  
+  class FXGLCanvas
+    alias old_initialize initialize
+    def initialize(parent, vis, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args[0].is_a?(FXGLCanvas))
+        sharegroup = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(parent, vis, sharegroup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(parent, vis, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+
+  class FXGLViewer
+    alias old_initialize initialize
+    def initialize(parent, vis, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args[0].is_a?(FXGLViewer))
+        sharegroup = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(parent, vis, sharegroup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(parent, vis, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+  
+  class FXMenuBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args[0].nil? || args[0].is_a?(FXComposite))
+        q = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      end
+    end
+  end
+
+  class FXSplitter
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => SPLITTER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }     
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args.first.nil? || args.first.is_a?(FXObject))
+        tgt, sel = args[0], args[1]
+        args.each_with_index { |e, i| params[argument_names[i-2].intern] = e if i >= 2 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, tgt, sel, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+
+  class FXToolBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }     
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args[0].nil? || args[0].is_a?(FXComposite))
+        q = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      end
+    end
+  end
+  
+  class FXWindow
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      if p.is_a? FXApp
+        old_initialize(p, *args, &blk)
+      else
+        argument_names = %w{opts x y width height}
+        default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+        params = {}
+        params = args.pop if args.last.is_a? Hash
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+