fxruby 1.6.19-x86-mingw32 → 1.6.20-x86-mingw32

data/ext/fox16/unregisterOwnedObjects.cpp

@@ -0,0 +1,120 @@
+/***********************************************************************
+ * $Id: unregisterOwnedObjects.cpp 2911 2008-12-11 14:09:45Z lyle $
+ ***********************************************************************/
+
+/**
+ * The purpose of an unregisterOwnedObjects() function for a particular
+ * class is to call FXRbUnregisterRubyObj() on any objects that this object
+ * created itself, and which it "owns" and will destroy in its destructor.
+ * This includes not only child widgets, like the horizontal and vertical
+ * scrollbars managed by an FXScrollArea, but other non-widget objects
+ * like list items.
+ *
+ * You don't need to worry about objects that the user created himself
+ * using Ruby code, because those should get unregistered automatically
+ * when they're destroyed. So, for example, if I create a button as a child
+ * of a frame, e.g.
+ *
+ *     FXButton.new(parentFrame, ...)
+ *
+ * that Ruby object's peer is an FXRbButton instance, and the destructor for
+ * the FXRbButton class calls FXRbUnregisterRubyObj(this). We only need to
+ * worry about the C++ objects that aren't subclasses of regular FOX classes,
+ * but which have somehow been "exposed" to the Ruby layer.
+ */
+ 
+#include "FXRbCommon.h"
+
+void FXRbHeader::unregisterOwnedObjects(FXHeader *self)
+{
+    // FXRbFrame::unregisterOwnedObjects(self);
+    for (FXint i = 0; i < self->getNumItems(); i++) FXRbUnregisterRubyObj(self->getItem(i));
+}
+
+void FXRbScrollArea::unregisterOwnedObjects(FXScrollArea *self)
+{
+    // FXRbComposite::unregisterOwnedObjects(self);
+    FXRbUnregisterRubyObj(self->horizontalScrollBar());
+    FXRbUnregisterRubyObj(self->verticalScrollBar());
+}
+
+/*
+void FXRbBitmapView::unregisterOwnedObjects(FXBitmapView *self)
+{
+    FXRbScrollArea::unregisterOwnedObjects(self);
+}
+*/
+
+void FXRbFoldingList::unregisterOwnedObjects(FXFoldingList *self)
+{
+    FXRbScrollArea::unregisterOwnedObjects(self);
+    FXRbUnregisterRubyObj(self->getHeader());
+    
+    // Save pointer(s) to the soon-to-be-destroyed items
+    FXObjectListOf<FXFoldingItem> items;
+    FXRbFoldingList::enumerateItems(self->getFirstItem(),self->getLastItem(),items);
+
+    // Now zero-out pointers held by still-alive Ruby objects
+    for (FXint i = 0; i <items.no(); i++) FXRbUnregisterRubyObj(items[i]);
+}
+
+void FXRbIconList::unregisterOwnedObjects(FXIconList *self)
+{
+    FXRbScrollArea::unregisterOwnedObjects(self);
+    FXRbUnregisterRubyObj(self->getHeader());
+    for (FXint i = 0; i <self->getNumItems(); i++) FXRbUnregisterRubyObj(self->getItem(i));
+}
+
+void FXRbImageView::unregisterOwnedObjects(FXImageView *self)
+{
+    FXRbScrollArea::unregisterOwnedObjects(self);
+}
+
+void FXRbList::unregisterOwnedObjects(FXList *self)
+{
+    FXRbScrollArea::unregisterOwnedObjects(self);
+    for (FXint i = 0; i < self->getNumItems(); i++) FXRbUnregisterRubyObj(self->getItem(i));
+}
+
+void FXRbColorList::unregisterOwnedObjects(FXColorList *self)
+{
+    FXRbList::unregisterOwnedObjects(self);
+}
+
+void FXRbScrollWindow::unregisterOwnedObjects(FXScrollWindow *self)
+{
+    FXRbScrollArea::unregisterOwnedObjects(self);
+}
+
+void FXRbTable::unregisterOwnedObjects(FXTable *self)
+{
+    FXint r,c;
+    FXRbScrollArea::unregisterOwnedObjects(self);
+    FXRbHeader::unregisterOwnedObjects(self->getRowHeader());
+    FXRbHeader::unregisterOwnedObjects(self->getColumnHeader());
+    FXRbUnregisterRubyObj(self->getRowHeader());
+    FXRbUnregisterRubyObj(self->getColumnHeader());
+    for(r=0; r<self->getNumRows(); r++){
+      for(c=0; c<self->getNumColumns(); c++){
+	FXRbUnregisterRubyObj(self->getItem(r,c));
+        }
+      }
+}
+
+void FXRbText::unregisterOwnedObjects(FXText *self)
+{
+    FXRbScrollArea::unregisterOwnedObjects(self);
+}
+
+void FXRbTreeList::unregisterOwnedObjects(FXTreeList *self)
+{
+    FXRbScrollArea::unregisterOwnedObjects(self);
+    
+    // Save pointer(s) to the soon-to-be-destroyed items
+    FXObjectListOf<FXTreeItem> items;
+    FXRbTreeList::enumerateItems(self->getFirstItem(), self->getLastItem(), items);
+
+    // Now zero-out pointers held by still-alive Ruby objects
+    for (FXint i = 0; i < items.no(); i++) FXRbUnregisterRubyObj(items[i]);
+}
+

data/lib/fox16.rb

@@ -0,0 +1,8 @@
+if RUBY_PLATFORM =~ /(mswin|mingw)/i
+  require "#{RUBY_VERSION.sub(/\.\d+$/, '')}/fox16.so"
+elsif RUBY_PLATFORM =~ /darwin/
+  require "fox16.bundle"
+else
+  require "fox16.so"
+end
+

data/lib/fox16/bitmapview.rb

@@ -0,0 +1,223 @@
+module Fox
+  #
+  # The FXBitmapView widget displays a scrollable view of a bitmap.
+  #
+  # === Bitmap alignment styles
+  #
+  # +BITMAPVIEW_NORMAL+::	Normal mode is centered
+  # +BITMAPVIEW_CENTER_X+::	Centered horizontally
+  # +BITMAPVIEW_LEFT+::		Left-aligned
+  # +BITMAPVIEW_RIGHT+::	Right-aligned
+  # +BITMAPVIEW_CENTER_Y+::	Centered vertically
+  # +BITMAPVIEW_TOP+::		Top-aligned
+  # +BITMAPVIEW_BOTTOM+::	Bottom-aligned
+  #
+  # === Events
+  #
+  # +SEL_RIGHTBUTTONPRESS+::	sent when the right mouse button goes down; the message data is an FXEvent instance.
+  # +SEL_RIGHTBUTTONRELEASE+::	sent when the right mouse button goes up; the message data is an FXEvent instance.
+  #
+  class FXBitmapView < FXScrollArea
+  
+    # Bitmap alignment styles
+    BITMAPVIEW_NORMAL    = 0          # Normal mode is centered
+    BITMAPVIEW_CENTER_X  = 0          # Centered horizontally
+    BITMAPVIEW_LEFT      = 0x00100000 # Left-aligned
+    BITMAPVIEW_RIGHT     = 0x00200000 # Right-aligned
+    BITMAPVIEW_CENTER_Y  = 0,         # Centered vertically
+    BITMAPVIEW_TOP       = 0x00400000 # Top-aligned
+    BITMAPVIEW_BOTTOM    = 0x00800000 # Bottom-aligned
+
+    #
+    # Return an initialized FXBitmapView instance.
+    #
+    def initialize(p, bmp=nil, tgt=nil, sel=0, opts=0, x=0, y=0, w=0, h=0) # :yields: theBitmapView
+      super(p, opts, x, y, w, h)
+      self.flags |= FLAG_ENABLED
+      self.target = tgt
+      self.message = sel
+      @bitmap = bmp
+      @onColor = FXRGB(0, 0, 0)
+      @offColor = backColor
+      @grabx = 0
+      @graby = 0
+    end
+
+    def create
+      super
+      bitmap.create unless bitmap.nil?
+    end
+
+    def detach
+      super
+      bitmap.detach unless bitmap.nil?
+    end
+
+    def canFocus
+      true
+    end
+
+    def getContentWidth
+      bitmap.nil? 1 : bitmap.width
+    end
+
+    def getContentHeight
+      bitmap.nil? 1 : bitmap.height
+    end
+
+    def layout
+      super
+      update
+      self.flags &= ~FLAG_DIRTY
+    end
+
+    # Handle expose (paint) event
+    def onPaint(sender, sel, event)
+      FXDCWindow.new(self, event) do |dc|
+        unless bitmap.nil?
+          ww = bitmap.width
+          hh = bitmap.height
+          xx = pos_x
+          yy = pos_y
+          if ww < viewport_w
+            if (options & BITMAPVIEW_LEFT) != 0
+              xx = 0
+            elsif (options & BITMAPVIEW_RIGHT) != 0
+              xx = viewport_w - ww
+            else
+              xx = (viewport_w - ww)/2
+            end
+          end
+          if hh < viewport_h
+            if (options & BITMAPVIEW_TOP) != 0
+              yy = 0
+            elsif (options & BITMAPVIEW_BOTTOM) != 0
+              yy = viewport_h - hh
+            else
+              yy = (viewport_h - hh)/2
+            end
+          end
+          dc.foreground = onColor
+          dc.background = offColor
+          dc.drawBitmap(bitmap, xx, yy)
+          dc.foreground = backColor
+          xl = xx; xr = xx + ww
+          yt = yy; yb = yy + hh
+          xl = 0 if (xl < 0)
+          xr = viewport_w if (xr > viewport_w)
+          yt = 0 if (yt < 0)
+          yb = viewport_h if (yb > viewport_h)
+          dc.fillRectangle(0, 0, xr, yt)
+          dc.fillRectangle(0, yt, xl, viewport_h - yt)
+          dc.fillRectangle(xr, 0, viewport_w - xr, yb)
+          dc.fillRectangle(xl, yb, viewport_w - xl, viewport_h - yb)
+        else
+          dc.foreground = backColor
+          dc.fillRectangle(0, 0, width, height)
+        end
+      end
+    end
+
+    # Handle right mouse button press
+    def onRightBtnPress(sender, sel, ev)
+      self.flags &= ~FLAG_TIP
+      handle(self, FXSEL(SEL_FOCUS_SELF, 0), ev)
+      if enabled?
+        grab
+        if target && target.handle(self, FXSEL(SEL_RIGHTBUTTONPRESS, message), ev) != 0
+          return 1
+        end
+        self.flags &= ~FLAG_UPDATE
+        self.flags |= FLAG_PRESSED|FLAG_SCROLLING
+        @grabx = ev.win_x - pos_x
+        @graby = ev.win_y - pos_y
+        return 1
+      end
+      return 0
+    end
+
+    # Handle right mouse button release
+    def onRightBtnRelease(sender, sel, ev)
+      if enabled?
+        ungrab
+        self.flags &= ~(FLAG_PRESSED|FLAG_SCROLLING)
+        self.flags |= FLAG_UPDATE
+        if target && target.handle(self, FXSEL(SEL_RIGHTBUTTONPRESS, message), ev) != 0 
+          return 1
+        end
+        return 1
+      end
+      return 0
+    end
+
+    # Handle real or simulated mouse motion
+    def onMotion(sender, sel, ev)
+      if (flags & FLAG_SCROLLING) != 0
+        setPosition(ev.win_x - @grabx, ev.win_y - @graby)
+        return 1
+      end
+      return 0
+    end
+
+    #
+    # Set the bitmap for this FXBitmapView, where _bmp_ is either +nil+ or
+    # a reference to an FXBitmap instance.
+    #
+    def bitmap=(bmp)
+      @bitmap = bmp
+      recalc
+      update
+    end
+
+    #
+    # Return a reference to the bitmap (an FXBitmap instance) for this FXBitmapView,
+    # or +nil+ if no bitmap has been set.
+    #
+    def bitmap; @bitmap; end
+
+    # Set the color used for the "on" bits in the bitmap.
+    def onColor=(clr)
+      if clr != onColor
+        @onColor = clr
+        update
+      end
+    end
+
+    # Return the color used for the "on" bits in the bitmap.
+    def onColor; @onColor; end
+
+    # Set the color used for the "off" bits in the bitmap.
+    def offColor=(clr)
+      if clr != offColor
+        @offColor = clr
+        update
+      end
+    end
+
+    # Return the color used for the "off" bits in the bitmap.
+    def offColor; @offColor; end
+
+    #
+    # Set the current alignment for the bitmap inside the FXBitmapView,
+    # where _mode_ is some combination of the bitmap alignment flags
+    # listed above.
+    #
+    def alignment=(mode)
+      opts = (options & ~(BITMAPVIEW_LEFT|BITMAPVIEW_RIGHT|BITMAPVIEW_TOP|BITMAPVIEW_BOTTOM)) |
+             (mode & (BITMAPVIEW_LEFT|BITMAPVIEW_RIGHT|BITMAPVIEW_TOP|BITMAPVIEW_BOTTOM))
+      if options != opts
+        @options = opts
+        update
+      end
+    end
+
+    #
+    # Return the current alignment for the bitmap inside the
+    # FXBitmapView.
+    #
+    def alignment
+      options & (BITMAPVIEW_LEFT|BITMAPVIEW_RIGHT|BITMAPVIEW_TOP|BITMAPVIEW_BOTTOM)
+    end
+  end
+end
+

data/lib/fox16/kwargs.rb

@@ -238,43 +238,39 @@ module Fox
     end
   end
 
-  class FX7Segment
+  class FXPNGIcon
     alias old_initialize initialize
-    def initialize(p, text, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :opts => SEVENSEGMENT_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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, text, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXApp
+  class FXGIFIcon
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{appName vendorName}
-      default_params = { :appName => "Application", :vendorName => "FoxDefault" }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       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(params[:appName], params[:vendorName], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXArrowButton
+  class FXShutterItem
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => ARROW_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, *args, &blk)
+      argument_names = %w{text icon opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :text => "", :icon => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -284,61 +280,75 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, params[:text], params[:icon], 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
 
-  class FXBitmap
+  class FXShutter
     alias old_initialize initialize
-    def initialize(app, *args, &blk)
-      argument_names = %w{pixels opts width height}
-      default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(app, params[:pixels], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], 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
 
-  class FXBitmapFrame
+  class FXScrollPane
     alias old_initialize initialize
-    def initialize(p, bmp, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+    def initialize(owner, nvis, *args, &blk)
+      argument_names = %w{opts}
+      default_params = { :opts => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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, bmp, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(owner, nvis, params[:opts], &blk)
     end
   end
 
-  class FXBitmapView
+  class FXIconItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{bigIcon miniIcon data}
+      default_params = { :bigIcon => nil, :miniIcon => nil, :data => nil }
+      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(text, params[:bigIcon], params[:miniIcon], params[:data], &blk)
+    end
+  end
+
+  class FXIconList
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{bmp target selector opts x y width height}
-      default_params = { :bmp => nil, :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => ICONLIST_NORMAL, :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[:bmp], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXBMPIcon
+  class FXPPMIcon
     alias old_initialize initialize
     def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => FXRGB(192,192,192), :opts => 0, :width => 1, :height => 1 }
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -348,7 +358,7 @@ module Fox
     end
   end
 
-  class FXBMPImage
+  class FXPPMImage
     alias old_initialize initialize
     def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
@@ -362,11 +372,25 @@ module Fox
     end
   end
 
-  class FXButton
+  class FXDelegator
     alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
-      argument_names = %w{icon target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :icon => nil, :target => nil, :selector => 0, :opts => BUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(*args, &blk)
+      argument_names = %w{delegate}
+      default_params = { :delegate => nil }
+      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(params[:delegate], &blk)
+    end
+  end
+
+  class FXToggleButton
+    alias old_initialize initialize
+    def initialize(p, text1, text2, *args, &blk)
+      argument_names = %w{icon1 icon2 target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon1 => nil, :icon2 => nil, :target => nil, :selector => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -376,29 +400,29 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:icon], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, text1, text2, params[:icon1], params[:icon2], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXCanvas
+  class FXFileSelector
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
+    def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      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
       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, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXCheckButton
+  class FXDockTitle
     alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
+    def initialize(p, text, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => CHECKBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL|JUSTIFY_CENTER_X|JUSTIFY_CENTER_Y, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -408,89 +432,103 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXChoiceBox
+  class FXICOIcon
     alias old_initialize initialize
-    def initialize(owner, caption, text, icon, choices, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       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(owner, caption, text, icon, choices, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXColorBar
+  class FXRGBImage
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXColorDialog
+  class FXApp
     alias old_initialize initialize
-    def initialize(owner, title, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(*args, &blk)
+      argument_names = %w{appName vendorName}
+      default_params = { :appName => "Application", :vendorName => "FoxDefault" }
       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(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(params[:appName], params[:vendorName], &blk)
     end
   end
 
-  class FXColorItem
+  class FXPopup
     alias old_initialize initialize
-    def initialize(text, clr, *args, &blk)
-      argument_names = %w{data}
-      default_params = { :data => nil }
+    def initialize(owner, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => POPUP_VERTICAL|FRAME_RAISED|FRAME_THICK, :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(text, clr, params[:data], &blk)
+      old_initialize(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXColorList
+  class FXColorRing
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => LIST_BROWSESELECT, :x => 0, :y => 0, :width => 0, :height => 0 }
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXColorRing
+  class FXMenuCheck
+    alias old_initialize initialize
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{target selector opts}
+      default_params = { :target => nil, :selector => 0, :opts => 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, text, params[:target], params[:selector], params[:opts], &blk)
+    end
+  end
+
+  class FXText
     alias old_initialize initialize
     def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -502,6 +540,17 @@ module Fox
       params = default_params.merge(params)
       old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
+    alias old_findText findText
+    def findText(string, *args)
+      argument_names = %w{start flags}
+      default_params = { :start => 0, :flags => SEARCH_FORWARD|SEARCH_WRAP|SEARCH_EXACT }
+      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_findText(string, params[:start], params[:flags])
+    end
   end
 
   class FXColorSelector
@@ -518,29 +567,25 @@ module Fox
     end
   end
 
-  class FXColorWell
+  class FXRulerView
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{color target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :color => 0, :target => nil, :selector => 0, :opts => COLORWELL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, *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
       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(parent, params[:color], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXColorWheel
+  class FXSeparator
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -550,15 +595,15 @@ module Fox
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXComboBox
+  class FXHorizontalSeparator
     alias old_initialize initialize
-    def initialize(p, cols, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => COMBOBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 1, :padRight => 1, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -568,57 +613,65 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXComposite
+  class FXVerticalSeparator
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_Y, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 1, :padBottom => 1 }
       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) }
+      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(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXDataTarget
+  class FXDial
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{value target selector}
-      default_params = { :value => nil, :target => nil, :selector => 0 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => DIAL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(params[:value], params[:target], params[:selector], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXDelegator
+  class FXFileStream
     alias old_initialize initialize
     def initialize(*args, &blk)
-      argument_names = %w{delegate}
-      default_params = { :delegate => nil }
+      argument_names = %w{cont}
+      default_params = { :cont => nil }
       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(params[:delegate], &blk)
+      old_initialize(params[:cont], &blk)
     end
   end
 
-  class FXDial
+  class FXRealSpinner
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
+    def initialize(p, cols, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => DIAL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      default_params = { :target => nil, :selector => 0, :opts => REALSPIN_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -628,33 +681,29 @@ module Fox
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXDialogBox
+  class FXDirDialog
     alias old_initialize initialize
-    def initialize(owner, title, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
-      default_params = { :opts => DECOR_TITLE|DECOR_BORDER, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 10, :padRight => 10, :padTop => 10, :padBottom => 10, :hSpacing => 4, :vSpacing => 4 }
+    def initialize(owner, name, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 500, :height => 300 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXDirBox
+  class FXPacker
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(parent, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -664,15 +713,15 @@ module Fox
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(parent, 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
 
-  class FXDirDialog
+  class FXFontDialog
     alias old_initialize initialize
     def initialize(owner, name, *args, &blk)
       argument_names = %w{opts x y width height}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 500, :height => 300 }
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 600, :height => 380 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -682,53 +731,53 @@ module Fox
     end
   end
 
-  class FXDirItem
+  class FXSearchDialog
     alias old_initialize initialize
-    def initialize(text, *args, &blk)
-      argument_names = %w{oi ci data}
-      default_params = { :oi => nil, :ci => nil, :data => nil }
+    def initialize(owner, caption, *args, &blk)
+      argument_names = %w{ic opts x y width height}
+      default_params = { :ic => nil, :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(text, params[:oi], params[:ci], params[:data], &blk)
+      old_initialize(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXDirList
+  class FXFileDict
     alias old_initialize initialize
-    def initialize(p, *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 }
+    def initialize(app, *args, &blk)
+      argument_names = %w{db}
+      default_params = { :db => nil }
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(app, params[:db], &blk)
     end
   end
 
-  class FXDirSelector
+  class FXTIFImage
     alias old_initialize initialize
-    def initialize(p, *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 }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXDockSite
+  class FXTextField
     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 => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0, :hSpacing => 0, :vSpacing => 0 }
+    def initialize(p, ncols, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => TEXTFIELD_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -738,33 +787,29 @@ module Fox
       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)
+      old_initialize(p, ncols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXDockTitle
+  class FXChoiceBox
     alias old_initialize initialize
-    def initialize(p, text, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL|JUSTIFY_CENTER_X|JUSTIFY_CENTER_Y, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+    def initialize(owner, caption, text, icon, choices, *args, &blk)
+      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 }
-      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, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(owner, caption, text, icon, choices, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXDriveBox
+  class FXTabBar
     alias old_initialize initialize
     def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      default_params = { :target => nil, :selector => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -778,109 +823,121 @@ module Fox
     end
   end
 
-  class FXFileDialog
+  class FXStream
     alias old_initialize initialize
-    def initialize(owner, name, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 500, :height => 300 }
+    def initialize(*args, &blk)
+      argument_names = %w{cont}
+      default_params = { :cont => nil }
       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(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(params[:cont], &blk)
     end
   end
 
-  class FXFileDict
+  class FXHeaderItem
     alias old_initialize initialize
-    def initialize(app, *args, &blk)
-      argument_names = %w{db}
-      default_params = { :db => nil }
+    def initialize(text, *args, &blk)
+      argument_names = %w{ic s ptr}
+      default_params = { :ic => nil, :s => 0, :ptr => nil }
       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(app, params[:db], &blk)
+      old_initialize(text, params[:ic], params[:s], params[:ptr], &blk)
     end
   end
 
-  class FXFileItem
+  class FXHeader
     alias old_initialize initialize
-    def initialize(text, *args, &blk)
-      argument_names = %w{bi mi ptr}
-      default_params = { :bi => nil, :mi => nil, :ptr => nil }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => HEADER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(text, params[:bi], params[:mi], params[:ptr], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXFileList
+  class FXRealSlider
     alias old_initialize initialize
     def initialize(p, *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 }
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => REALSLIDER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXFileSelector
+  class FXScrollArea
     alias old_initialize initialize
-    def initialize(p, *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 }
+    def initialize(parent, *args, &blk)
+      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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXFileStream
+  class FXImageFrame
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{cont}
-      default_params = { :cont => nil }
+    def initialize(p, img, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(params[:cont], &blk)
+      old_initialize(p, img, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXFoldingItem
+  class FXListItem
     alias old_initialize initialize
     def initialize(text, *args, &blk)
-      argument_names = %w{openIcon closedIcon data}
-      default_params = { :openIcon => nil, :closedIcon => nil, :data => nil }
+      argument_names = %w{icon data}
+      default_params = { :icon => nil, :data => nil }
       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(text, params[:openIcon], params[:closedIcon], params[:data], &blk)
+      old_initialize(text, params[:icon], params[:data], &blk)
     end
   end
 
-  class FXFoldingList
+  class FXList
     alias old_initialize initialize
     def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => TREELIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      default_params = { :target => nil, :selector => 0, :opts => LIST_NORMAL, :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 }
@@ -890,105 +947,73 @@ module Fox
     end
   end
 
-  class FXFontDialog
+  class FXReplaceDialog
     alias old_initialize initialize
-    def initialize(owner, name, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 600, :height => 380 }
+    def initialize(owner, caption, *args, &blk)
+      argument_names = %w{ic opts x y width height}
+      default_params = { :ic => nil, :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(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXFontSelector
+  class FXComposite
     alias old_initialize initialize
-    def initialize(p, *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 }
+    def initialize(parent, *args, &blk)
+      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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXFrame
+  class FXMDIChild
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, name, *args, &blk)
+      argument_names = %w{ic pup opts x y width height}
+      default_params = { :ic => nil, :pup => nil, :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 }
-      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(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, name, params[:ic], params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXGIFCursor
+  class FXScrollWindow
     alias old_initialize initialize
-    def initialize(a, pix, *args, &blk)
-      argument_names = %w{hx hy}
-      default_params = { :hx => -1, :hy => -1 }
+    def initialize(p, *args, &blk)
+      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(a, pix, params[:hx], params[:hy], &blk)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXGIFIcon
+  class FXBitmapView
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
-      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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
-    end
-  end
-
-  class FXGIFImage
-    alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix opts width height}
-      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
-      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(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
-    end
-  end
-
-  class FXGLContext
-    alias old_initialize initialize
-    def initialize(app, visual, *args, &blk)
-      argument_names = %w{other}
-      default_params = { :other => nil }
+    def initialize(p, *args, &blk)
+      argument_names = %w{bmp target selector opts x y width height}
+      default_params = { :bmp => nil, :target => nil, :selector => 0, :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(app, visual, params[:other], &blk)
+      old_initialize(p, params[:bmp], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
@@ -1010,177 +1035,159 @@ module Fox
     end
   end
 
-  class FXGroupBox
-    alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
-      default_params = { :opts => GROUPBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
-      params = {}
-      params = args.pop if args.last.is_a? Hash
-      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(parent, text, 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
-
-  class FXHeaderItem
+  class FXMDIDeleteButton
     alias old_initialize initialize
-    def initialize(text, *args, &blk)
-      argument_names = %w{ic s ptr}
-      default_params = { :ic => nil, :s => 0, :ptr => nil }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :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(text, params[:ic], params[:s], params[:ptr], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXHeader
+  class FXMDIRestoreButton
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => HEADER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :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 }
-      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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXHorizontalFrame
+  class FXMDIMaximizeButton
     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 => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :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 }
-      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)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXICOIcon
+  class FXMDIMinimizeButton
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXICOImage
+  class FXMDIWindowButton
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix opts width height}
-      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+    def initialize(p, pup, *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
       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(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(p, pup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXIcon
+  class FXMDIMenu
     alias old_initialize initialize
-    def initialize(app, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+    def initialize(owner, *args, &blk)
+      argument_names = %w{target}
+      default_params = { :target => nil }
       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(app, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(owner, params[:target], &blk)
     end
   end
 
-  class FXIconDict
+  class FXToolTip
     alias old_initialize initialize
     def initialize(app, *args, &blk)
-      argument_names = %w{path}
-      default_params = { :path => FXIconDict.defaultIconPath }
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => TOOLTIP_NORMAL, :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(app, params[:path], &blk)
+      old_initialize(app, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXIconItem
+  class FXColorWell
     alias old_initialize initialize
-    def initialize(text, *args, &blk)
-      argument_names = %w{bigIcon miniIcon data}
-      default_params = { :bigIcon => nil, :miniIcon => nil, :data => nil }
+    def initialize(parent, *args, &blk)
+      argument_names = %w{color target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :color => 0, :target => nil, :selector => 0, :opts => COLORWELL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(text, params[:bigIcon], params[:miniIcon], params[:data], &blk)
+      old_initialize(parent, params[:color], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXIconList
+  class FXXPMImage
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => ICONLIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXImage
+  class FXMatrix
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pixels opts width height}
-      default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
+    def initialize(parent, *args, &blk)
+      argument_names = %w{n opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :n => 1, :opts => MATRIX_BY_ROWS, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(a, params[:pixels], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(parent, params[:n], 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
 
-  class FXImageFrame
+  class FXKnob
     alias old_initialize initialize
-    def initialize(p, img, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => KNOB_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -1190,53 +1197,53 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, img, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXImageView
+  class FXCanvas
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{img target selector opts x y width height}
-      default_params = { :img => nil, :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(parent, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :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[:img], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXInputDialog
+  class FXColorItem
     alias old_initialize initialize
-    def initialize(owner, caption, label, *args, &blk)
-      argument_names = %w{icon opts x y width height}
-      default_params = { :icon => nil, :opts => INPUTDIALOG_STRING, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(text, clr, *args, &blk)
+      argument_names = %w{data}
+      default_params = { :data => nil }
       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(owner, caption, label, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(text, clr, params[:data], &blk)
     end
   end
 
-  class FXJPGIcon
+  class FXColorList
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => LIST_BROWSESELECT, :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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXJPGImage
+  class FXPNGImage
     alias old_initialize initialize
     def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
@@ -1250,75 +1257,39 @@ module Fox
     end
   end
 
-  class FXKnob
-    alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => KNOB_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
-      params = {}
-      params = args.pop if args.last.is_a? Hash
-      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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
-    end
-  end
-
-  class FXLabel
-    alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
-      argument_names = %w{icon opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :icon => nil, :opts => LABEL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
-      params = {}
-      params = args.pop if args.last.is_a? Hash
-      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(parent, text, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
-    end
-  end
-
-  class FXListItem
+  class FXJPGIcon
     alias old_initialize initialize
-    def initialize(text, *args, &blk)
-      argument_names = %w{icon data}
-      default_params = { :icon => nil, :data => nil }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       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(text, params[:icon], params[:data], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXList
+  class FXMenuRadio
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => LIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{target selector opts}
+      default_params = { :target => nil, :selector => 0, :opts => 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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, text, params[:target], params[:selector], params[:opts], &blk)
     end
   end
 
-  class FXListBox
+  class FXOption
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{ic target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :ic => nil, :target => nil, :selector => 0, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -1328,15 +1299,15 @@ module Fox
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXMainWindow
+  class FXOptionMenu
     alias old_initialize initialize
-    def initialize(app, title, *args, &blk)
-      argument_names = %w{icon miniIcon opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
-      default_params = { :icon => nil, :miniIcon => nil, :opts => DECOR_ALL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0, :hSpacing => 4, :vSpacing => 4 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{pup opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :pup => nil, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -1346,57 +1317,53 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(app, title, params[:icon], params[:miniIcon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(p, params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXMatrix
+  class FXIconDict
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{n opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
-      default_params = { :n => 1, :opts => MATRIX_BY_ROWS, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+    def initialize(app, *args, &blk)
+      argument_names = %w{path}
+      default_params = { :path => FXIconDict.defaultIconPath }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(parent, params[:n], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(app, params[:path], &blk)
     end
   end
 
-  class FXMDIDeleteButton
+  class FXVisual
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(a, flgs, *args, &blk)
+      argument_names = %w{d}
+      default_params = { :d => 32 }
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(a, flgs, params[:d], &blk)
     end
   end
 
-  class FXMDIRestoreButton
+  class FXRegistry
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(*args, &blk)
+      argument_names = %w{appKey vendorKey}
+      default_params = { :appKey => "", :vendorKey => "" }
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(params[:appKey], params[:vendorKey], &blk)
     end
   end
 
-  class FXMDIMaximizeButton
+  class FXToolBarTab
     alias old_initialize initialize
     def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height}
@@ -1410,95 +1377,99 @@ module Fox
     end
   end
 
-  class FXMDIMinimizeButton
+  class FXFrame
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(parent, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXMDIWindowButton
+  class FXXBMImage
     alias old_initialize initialize
-    def initialize(p, pup, *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 }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pixels mask opts width height}
+      default_params = { :pixels => nil, :mask => nil, :opts => 0, :width => 1, :height => 1 }
       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, pup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pixels], params[:mask], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXMDIMenu
+  class FXFileItem
     alias old_initialize initialize
-    def initialize(owner, *args, &blk)
-      argument_names = %w{target}
-      default_params = { :target => nil }
+    def initialize(text, *args, &blk)
+      argument_names = %w{bi mi ptr}
+      default_params = { :bi => nil, :mi => nil, :ptr => nil }
       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(owner, params[:target], &blk)
+      old_initialize(text, params[:bi], params[:mi], params[:ptr], &blk)
     end
   end
 
-  class FXMDIChild
+  class FXFileList
     alias old_initialize initialize
-    def initialize(p, name, *args, &blk)
-      argument_names = %w{ic pup opts x y width height}
-      default_params = { :ic => nil, :pup => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(p, *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
       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, name, params[:ic], params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXMDIClient
+  class FXMessageBox
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(owner, caption, text, *args, &blk)
+      argument_names = %w{ic opts x y}
+      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 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)
+      old_initialize(owner, caption, text, params[:ic], params[:opts], params[:x], params[:y], &blk)
     end
   end
 
-  class FXMemoryStream
+  class FXTableItem
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{cont}
-      default_params = { :cont => nil }
+    def initialize(text, *args, &blk)
+      argument_names = %w{icon data}
+      default_params = { :icon => nil, :data => nil }
       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(params[:cont], &blk)
+      old_initialize(text, params[:icon], params[:data], &blk)
     end
   end
 
-  class FXMenuButton
+  class FXTable
     alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
-      argument_names = %w{icon popupMenu opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :icon => nil, :popupMenu => nil, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT|MENUBUTTON_DOWN, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_MARGIN, :padRight => DEFAULT_MARGIN, :padTop => DEFAULT_MARGIN, :padBottom => DEFAULT_MARGIN }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -1508,159 +1479,143 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
-    end
-  end
-
-  class FXMenuCaption
-    alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
-      argument_names = %w{icon opts}
-      default_params = { :icon => nil, :opts => 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(parent, text, params[:icon], params[:opts], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXMenuCascade
+  class FXTabBook
     alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
-      argument_names = %w{icon popupMenu opts}
-      default_params = { :icon => nil, :popupMenu => nil, :opts => 0 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(parent, text, params[:icon], params[:popupMenu], params[:opts], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXMenuCheck
+  class FXDataTarget
     alias old_initialize initialize
-    def initialize(p, text, *args, &blk)
-      argument_names = %w{target selector opts}
-      default_params = { :target => nil, :selector => 0, :opts => 0 }
+    def initialize(*args, &blk)
+      argument_names = %w{value target selector}
+      default_params = { :value => nil, :target => nil, :selector => 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, text, params[:target], params[:selector], params[:opts], &blk)
+      old_initialize(params[:value], params[:target], params[:selector], &blk)
     end
   end
 
-  class FXMenuCommand
+  class FXStatusLine
     alias old_initialize initialize
-    def initialize(p, text, *args, &blk)
-      argument_names = %w{ic target selector opts}
-      default_params = { :ic => nil, :target => nil, :selector => 0, :opts => 0 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector}
+      default_params = { :target => nil, :selector => 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, text, params[:ic], params[:target], params[:selector], params[:opts], &blk)
+      old_initialize(p, params[:target], params[:selector], &blk)
     end
   end
 
-  class FXMenuPane
+  class FXGroupBox
     alias old_initialize initialize
-    def initialize(owner, *args, &blk)
-      argument_names = %w{opts}
-      default_params = { :opts => 0 }
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => GROUPBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(owner, params[:opts], &blk)
+      old_initialize(parent, text, 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
 
-  class FXMenuRadio
+  class FXProgressBar
     alias old_initialize initialize
-    def initialize(p, text, *args, &blk)
-      argument_names = %w{target selector opts}
-      default_params = { :target => nil, :selector => 0, :opts => 0 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => PROGRESSBAR_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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, text, params[:target], params[:selector], params[:opts], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXMenuSeparator
+  class FXProgressDialog
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{opts}
-      default_params = { :opts => 0 }
+    def initialize(owner, caption, label, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => PROGRESSDIALOG_NORMAL, :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(parent, params[:opts], &blk)
+      old_initialize(owner, caption, label, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXMenuTitle
+  class FXMenuButton
     alias old_initialize initialize
     def initialize(parent, text, *args, &blk)
-      argument_names = %w{icon popupMenu opts}
-      default_params = { :icon => nil, :popupMenu => nil, :opts => 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(parent, text, params[:icon], params[:popupMenu], params[:opts], &blk)
-    end
-  end
-
-  class FXMessageBox
-    alias old_initialize initialize
-    def initialize(owner, caption, text, *args, &blk)
-      argument_names = %w{ic opts x y}
-      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0 }
+      argument_names = %w{icon popupMenu opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon => nil, :popupMenu => nil, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT|MENUBUTTON_DOWN, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(owner, caption, text, params[:ic], params[:opts], params[:x], params[:y], &blk)
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXOption
+  class FXRGBIcon
     alias old_initialize initialize
-    def initialize(p, text, *args, &blk)
-      argument_names = %w{ic target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :ic => nil, :target => nil, :selector => 0, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXOptionMenu
+  class FX7Segment
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{pup opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :pup => nil, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => SEVENSEGMENT_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -1670,15 +1625,15 @@ module Fox
       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[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, text, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXPacker
+  class FXTreeListBox
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -1688,71 +1643,67 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXPCXIcon
+  class FXSplashWindow
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+    def initialize(owner, icon, *args, &blk)
+      argument_names = %w{opts ms}
+      default_params = { :opts => SPLASH_SIMPLE, :ms => 5000 }
       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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(owner, icon, params[:opts], params[:ms], &blk)
     end
   end
 
-  class FXPCXImage
+  class FXMenuCaption
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix opts width height}
-      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon opts}
+      default_params = { :icon => nil, :opts => 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(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(parent, text, params[:icon], params[:opts], &blk)
     end
   end
 
-  class FXPicker
+  class FXMDIClient
     alias old_initialize initialize
-    def initialize(p, text, *args, &blk)
-      argument_names = %w{ic target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :ic => nil, :target => nil, :selector => 0, :opts => BUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, *args, &blk)
+      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 }
-      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, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXPNGIcon
+  class FXMenuTitle
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon popupMenu opts}
+      default_params = { :icon => nil, :popupMenu => nil, :opts => 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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], &blk)
     end
   end
 
-  class FXPNGImage
+  class FXICOImage
     alias old_initialize initialize
     def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
@@ -1766,99 +1717,99 @@ module Fox
     end
   end
 
-  class FXPopup
+  class FXDirBox
     alias old_initialize initialize
-    def initialize(owner, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => POPUP_VERTICAL|FRAME_RAISED|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXPPMIcon
+  class FXScrollBar
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => SCROLLBAR_VERTICAL, :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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXPPMImage
+  class FXDirSelector
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix opts width height}
-      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+    def initialize(p, *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
       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(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXPrintDialog
+  class FXBitmap
     alias old_initialize initialize
-    def initialize(owner, name, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(app, *args, &blk)
+      argument_names = %w{pixels opts width height}
+      default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
       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(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(app, params[:pixels], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXProgressBar
+  class FXIcon
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => PROGRESSBAR_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(app, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(app, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXProgressDialog
+  class FXFontSelector
     alias old_initialize initialize
-    def initialize(owner, caption, label, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => PROGRESSDIALOG_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(p, *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
       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(owner, caption, label, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXRadioButton
+  class FXMainWindow
     alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => RADIOBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(app, title, *args, &blk)
+      argument_names = %w{icon miniIcon opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :icon => nil, :miniIcon => nil, :opts => DECOR_ALL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0, :hSpacing => 4, :vSpacing => 4 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -1868,15 +1819,15 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(app, title, params[:icon], params[:miniIcon], 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
 
-  class FXRealSlider
+  class FXSlider
     alias old_initialize initialize
     def initialize(p, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => REALSLIDER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+      default_params = { :target => nil, :selector => 0, :opts => SLIDER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -1890,11 +1841,25 @@ module Fox
     end
   end
 
-  class FXRealSpinner
+  class FXScintilla
     alias old_initialize initialize
-    def initialize(p, cols, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => REALSPIN_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, *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
+      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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXDockSite
+    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 => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0, :hSpacing => 0, :vSpacing => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -1904,53 +1869,53 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      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
 
-  class FXRegistry
+  class FXImageView
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{appKey vendorKey}
-      default_params = { :appKey => "", :vendorKey => "" }
+    def initialize(p, *args, &blk)
+      argument_names = %w{img target selector opts x y width height}
+      default_params = { :img => nil, :target => nil, :selector => 0, :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(params[:appKey], params[:vendorKey], &blk)
+      old_initialize(p, params[:img], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXReplaceDialog
+  class FXMenuCommand
     alias old_initialize initialize
-    def initialize(owner, caption, *args, &blk)
-      argument_names = %w{ic opts x y width height}
-      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{ic target selector opts}
+      default_params = { :ic => nil, :target => nil, :selector => 0, :opts => 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(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], &blk)
     end
   end
 
-  class FXRGBIcon
+  class FXPCXImage
     alias old_initialize initialize
     def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXRGBImage
+  class FXTGAImage
     alias old_initialize initialize
     def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
@@ -1964,43 +1929,53 @@ module Fox
     end
   end
 
-  class FXRuler
+  class FXXPMIcon
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => RULER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXRulerView
+  class FXMenuCascade
     alias old_initialize initialize
-    def initialize(p, *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 }
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon popupMenu opts}
+      default_params = { :icon => nil, :popupMenu => nil, :opts => 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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], &blk)
     end
   end
 
-  class FXScintilla
+  class FXFoldingItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{openIcon closedIcon data}
+      default_params = { :openIcon => nil, :closedIcon => nil, :data => nil }
+      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(text, params[:openIcon], params[:closedIcon], params[:data], &blk)
+    end
+  end
+
+  class FXFoldingList
     alias old_initialize initialize
     def initialize(p, *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 }
+      default_params = { :target => nil, :selector => 0, :opts => TREELIST_NORMAL, :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 }
@@ -2010,51 +1985,59 @@ module Fox
     end
   end
 
-  class FXScrollArea
+  class FXPCXIcon
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       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(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXScrollBar
+  class FXSwitcher
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => SCROLLBAR_VERTICAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXScrollPane
+  class FXCheckButton
     alias old_initialize initialize
-    def initialize(owner, nvis, *args, &blk)
-      argument_names = %w{opts}
-      default_params = { :opts => 0 }
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => CHECKBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(owner, nvis, params[:opts], &blk)
+      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXScrollWindow
+  class FXPrintDialog
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
+    def initialize(owner, name, *args, &blk)
       argument_names = %w{opts x y width height}
       default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
       params = {}
@@ -2062,47 +2045,43 @@ module Fox
       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)
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXSearchDialog
+  class FXFileDialog
     alias old_initialize initialize
-    def initialize(owner, caption, *args, &blk)
-      argument_names = %w{ic opts x y width height}
-      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(owner, name, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 500, :height => 300 }
       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(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXSeparator
+  class FXGIFImage
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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], &blk)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXHorizontalSeparator
+  class FXTabItem
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 1, :padRight => 1, :padTop => 0, :padBottom => 0 }
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{ic opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :ic => nil, :opts => TAB_TOP_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2112,51 +2091,43 @@ module Fox
       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], &blk)
+      old_initialize(p, text, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXVerticalSeparator
+  class FXTIFIcon
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_Y, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 1, :padBottom => 1 }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXShutterItem
+  class FXTGAIcon
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{text icon opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
-      default_params = { :text => "", :icon => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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[:text], params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXShutter
+  class FXVerticalFrame
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
-      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2166,65 +2137,57 @@ module Fox
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      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
 
-  class FXSlider
+  class FXMenuSeparator
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => SLIDER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+    def initialize(parent, *args, &blk)
+      argument_names = %w{opts}
+      default_params = { :opts => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(parent, params[:opts], &blk)
     end
   end
 
-  class FXSpinner
+  class FXGIFCursor
     alias old_initialize initialize
-    def initialize(p, cols, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => SPIN_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(a, pix, *args, &blk)
+      argument_names = %w{hx hy}
+      default_params = { :hx => -1, :hy => -1 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(a, pix, params[:hx], params[:hy], &blk)
     end
   end
 
-  class FXSplashWindow
+  class FXToolBarGrip
     alias old_initialize initialize
-    def initialize(owner, icon, *args, &blk)
-      argument_names = %w{opts ms}
-      default_params = { :opts => SPLASH_SIMPLE, :ms => 5000 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => TOOLBARGRIP_SINGLE, :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(owner, icon, params[:opts], params[:ms], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXSpring
+  class FXColorWheel
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{opts relw relh x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
-      default_params = { :opts => 0, :relw => 0, :relh => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2234,15 +2197,15 @@ module Fox
       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[:relw], params[:relh], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXStatusBar
+  class FXArrowButton
     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 => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => 4, :vSpacing => 0 }
+    def initialize(parent, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => ARROW_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2252,61 +2215,61 @@ module Fox
       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)
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXStatusLine
+  class FXBMPIcon
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector}
-      default_params = { :target => nil, :selector => 0 }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => FXRGB(192,192,192), :opts => 0, :width => 1, :height => 1 }
       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[:target], params[:selector], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXStream
+  class FXComboBox
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{cont}
-      default_params = { :cont => nil }
+    def initialize(p, cols, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => COMBOBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(params[:cont], &blk)
+      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXSwitcher
+  class FXToolBarShell
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
+    def initialize(owner, *args, &blk)
+      argument_names = %w{opts x y width height hSpacing vSpacing}
+      default_params = { :opts => FRAME_RAISED|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :hSpacing => 4, :vSpacing => 4 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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], &blk)
+      old_initialize(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
-  class FXTabBar
+  class FXColorBar
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
+    def initialize(parent, *args, &blk)
       argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2316,15 +2279,15 @@ module Fox
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXTabBook
+  class FXPicker
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{ic target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :ic => nil, :target => nil, :selector => 0, :opts => BUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2334,15 +2297,15 @@ module Fox
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXTabItem
+  class FXBitmapFrame
     alias old_initialize initialize
-    def initialize(p, text, *args, &blk)
-      argument_names = %w{ic opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :ic => nil, :opts => TAB_TOP_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, bmp, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2352,76 +2315,75 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, bmp, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXTableItem
+  class FXWizard
     alias old_initialize initialize
-    def initialize(text, *args, &blk)
-      argument_names = %w{icon data}
-      default_params = { :icon => nil, :data => nil }
+    def initialize(owner, name, image, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :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 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(text, params[:icon], params[:data], &blk)
+      old_initialize(owner, name, image, 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
 
-  class FXTable
+  class FXMemoryStream
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_MARGIN, :padRight => DEFAULT_MARGIN, :padTop => DEFAULT_MARGIN, :padBottom => DEFAULT_MARGIN }
+    def initialize(*args, &blk)
+      argument_names = %w{cont}
+      default_params = { :cont => nil }
       params = {}
       params = args.pop if args.last.is_a? Hash
-      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
+      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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(params[:cont], &blk)
     end
   end
 
-  class FXText
+  class FXInputDialog
     alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2 }
+    def initialize(owner, caption, label, *args, &blk)
+      argument_names = %w{icon opts x y width height}
+      default_params = { :icon => nil, :opts => INPUTDIALOG_STRING, :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 }
-      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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(owner, caption, label, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
-    alias old_findText findText
-    def findText(string, *args)
-      argument_names = %w{start flags}
-      default_params = { :start => 0, :flags => SEARCH_FORWARD|SEARCH_WRAP|SEARCH_EXACT }
+  end
+
+  class FXGLContext
+    alias old_initialize initialize
+    def initialize(app, visual, *args, &blk)
+      argument_names = %w{other}
+      default_params = { :other => nil }
       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_findText(string, params[:start], params[:flags])
+      old_initialize(app, visual, params[:other], &blk)
     end
   end
 
-  class FXTextField
+  class FXLabel
     alias old_initialize initialize
-    def initialize(p, ncols, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => TEXTFIELD_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon => nil, :opts => LABEL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2431,71 +2393,75 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, ncols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(parent, text, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXTGAIcon
+  class FXXBMIcon
     alias old_initialize initialize
     def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      argument_names = %w{pixels mask clr opts width height}
+      default_params = { :pixels => nil, :mask => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
       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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pixels], params[:mask], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXTGAImage
+  class FXImage
     alias old_initialize initialize
     def initialize(a, *args, &blk)
-      argument_names = %w{pix opts width height}
-      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      argument_names = %w{pixels opts width height}
+      default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
       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(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pixels], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXTIFIcon
+  class FXListBox
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXTIFImage
+  class FXColorDialog
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix opts width height}
-      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+    def initialize(owner, title, *args, &blk)
+      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(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXToggleButton
+  class FXRadioButton
     alias old_initialize initialize
-    def initialize(p, text1, text2, *args, &blk)
-      argument_names = %w{icon1 icon2 target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :icon1 => nil, :icon2 => nil, :target => nil, :selector => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => RADIOBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2505,63 +2471,57 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text1, text2, params[:icon1], params[:icon2], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
-    end
-  end
-
-  class FXToolBarGrip
-    alias old_initialize initialize
-    def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => TOOLBARGRIP_SINGLE, :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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXToolBarShell
+  class FXTriStateButton
     alias old_initialize initialize
-    def initialize(owner, *args, &blk)
-      argument_names = %w{opts x y width height hSpacing vSpacing}
-      default_params = { :opts => FRAME_RAISED|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :hSpacing => 4, :vSpacing => 4 }
+    def initialize(p, text1, text2, text3, *args, &blk)
+      argument_names = %w{icon1 icon2 icon3 target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon1 => nil, :icon2 => nil, :icon3 => nil, :target => nil, :selector => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(p, text1, text2, text3, params[:icon1], params[:icon2], params[:icon3], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXToolBarTab
+  class FXHorizontalFrame
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      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
 
-  class FXToolTip
+  class FXJPGImage
     alias old_initialize initialize
-    def initialize(app, *args, &blk)
-      argument_names = %w{opts x y width height}
-      default_params = { :opts => TOOLTIP_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
       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(app, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
@@ -2593,11 +2553,11 @@ module Fox
     end
   end
 
-  class FXTreeListBox
+  class FXSpring
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      argument_names = %w{opts relw relh x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :relw => 0, :relh => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2607,15 +2567,15 @@ module Fox
       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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, params[:opts], params[:relw], params[:relh], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
-  class FXTriStateButton
+  class FXRuler
     alias old_initialize initialize
-    def initialize(p, text1, text2, text3, *args, &blk)
-      argument_names = %w{icon1 icon2 icon3 target selector opts x y width height padLeft padRight padTop padBottom}
-      default_params = { :icon1 => nil, :icon2 => nil, :icon3 => nil, :target => nil, :selector => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => RULER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2625,15 +2585,29 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(p, text1, text2, text3, params[:icon1], params[:icon2], params[:icon3], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXVerticalFrame
+  class FXMenuPane
+    alias old_initialize initialize
+    def initialize(owner, *args, &blk)
+      argument_names = %w{opts}
+      default_params = { :opts => 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(owner, params[:opts], &blk)
+    end
+  end
+
+  class FXDriveBox
     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 => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2643,29 +2617,33 @@ module Fox
       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)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXVisual
+  class FXSpinner
     alias old_initialize initialize
-    def initialize(a, flgs, *args, &blk)
-      argument_names = %w{d}
-      default_params = { :d => 32 }
+    def initialize(p, cols, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => SPIN_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(a, flgs, params[:d], &blk)
+      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXWizard
+  class FXDialogBox
     alias old_initialize initialize
-    def initialize(owner, name, image, *args, &blk)
+    def initialize(owner, title, *args, &blk)
       argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
-      default_params = { :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 }
+      default_params = { :opts => DECOR_TITLE|DECOR_BORDER, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 10, :padRight => 10, :padTop => 10, :padBottom => 10, :hSpacing => 4, :vSpacing => 4 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2675,53 +2653,57 @@ module Fox
       end
       params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
       params = default_params.merge(params)
-      old_initialize(owner, name, image, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(owner, title, 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
 
-  class FXXBMIcon
+  class FXDirItem
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pixels mask clr opts width height}
-      default_params = { :pixels => nil, :mask => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+    def initialize(text, *args, &blk)
+      argument_names = %w{oi ci data}
+      default_params = { :oi => nil, :ci => nil, :data => nil }
       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(a, params[:pixels], params[:mask], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(text, params[:oi], params[:ci], params[:data], &blk)
     end
   end
 
-  class FXXBMImage
+  class FXDirList
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pixels mask opts width height}
-      default_params = { :pixels => nil, :mask => nil, :opts => 0, :width => 1, :height => 1 }
+    def initialize(p, *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
       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(a, params[:pixels], params[:mask], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXXPMIcon
+  class FXButton
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
-      argument_names = %w{pix clr opts width height}
-      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon => nil, :target => nil, :selector => 0, :opts => BUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
       params = {}
       params = args.pop if args.last.is_a? Hash
       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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(parent, text, params[:icon], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXXPMImage
+  class FXBMPImage
     alias old_initialize initialize
     def initialize(a, *args, &blk)
       argument_names = %w{pix opts width height}
@@ -2735,6 +2717,24 @@ module Fox
     end
   end
 
+  class FXStatusBar
+    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 => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => 4, :vSpacing => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      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
 
 $VERBOSE = true