fxruby 1.6.22.pre3 → 1.6.22.pre4

data/doap.rdf

@@ -77,8 +77,8 @@
     <doap:release>
       <doap:Version>
         <doap:branch>fox16</doap:branch>
-        <doap:created>2012-01-29</doap:created>
-        <doap:revision>1.6.22</doap:revision>
+        <doap:created>2012-02-16</doap:created>
+        <doap:revision>1.6.22.pre4</doap:revision>
       </doap:Version>
     </doap:release>
 

data/ext/fox16/FXRuby.cpp

@@ -448,6 +448,36 @@ VALUE FXRbMakeColorArray(const FXColor* colors,FXint w,FXint h){
   return result;
   }
 
+FXuint FXRbNumberOfFXColors(VALUE string_or_ary){
+  FXuint len;
+
+  if(TYPE(string_or_ary) == T_ARRAY){
+    len = RARRAY_LEN(string_or_ary);
+  }else{
+    Check_Type(string_or_ary,T_STRING);
+    if(RSTRING_LEN(string_or_ary) % sizeof(FXColor) != 0 )
+      rb_raise( rb_eArgError, "String size is no multiple of %lu", sizeof(FXColor) );
+    len = RSTRING_LEN(string_or_ary) / sizeof(FXColor);
+  }
+  return len;
+}
+
+FXColor *FXRbConvertToFXColors(VALUE string_or_ary){
+  FXColor* pix=0;
+  if(TYPE(string_or_ary) == T_ARRAY){
+    if(FXMALLOC(&pix,FXColor,RARRAY_LEN(string_or_ary))){
+      for(long i=0; i<RARRAY_LEN(string_or_ary); i++){
+        pix[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(string_or_ary,i)));
+      }
+    }
+  }else{
+    if(FXMALLOC(&pix,FXColor,RSTRING_LEN(string_or_ary)/sizeof(FXColor))){
+      memcpy(pix, RSTRING_PTR(string_or_ary), RSTRING_LEN(string_or_ary));
+    }
+  }
+  return pix;
+}
+
 //----------------------------------------------------------------------
 
 /**
@@ -1536,7 +1566,7 @@ FXwchar FXRbCallWCharMethod(const FXObject* recv, ID func){
 FXRbMenuCommand::~FXRbMenuCommand(){
   FXAccelTable *table;
   FXWindow *owner;
-  if(acckey){
+  if(acckey && !FXRbIsInGC(this)){
     owner=getShell()->getOwner();
     if(owner){
       table=owner->getAccelTable();
@@ -1552,7 +1582,7 @@ FXRbMenuCommand::~FXRbMenuCommand(){
 FXRbMenuCheck::~FXRbMenuCheck(){
   FXAccelTable *table;
   FXWindow *owner;
-  if(acckey){
+  if(acckey && !FXRbIsInGC(this)){
     owner=getShell()->getOwner();
     if(owner){
       table=owner->getAccelTable();
@@ -1568,7 +1598,7 @@ FXRbMenuCheck::~FXRbMenuCheck(){
 FXRbMenuRadio::~FXRbMenuRadio(){
   FXAccelTable *table;
   FXWindow *owner;
-  if(acckey){
+  if(acckey && !FXRbIsInGC(this)){
     owner=getShell()->getOwner();
     if(owner){
       table=owner->getAccelTable();

data/ext/fox16/image_wrap.cpp

@@ -690,28 +690,62 @@ FXColor FXMemoryBuffer___setitem__(FXMemoryBuffer *self,FXuint i,FXColor value){
 
 swig_class cFXMemoryBuffer;
 static void free_FXMemoryBuffer(FXMemoryBuffer *);
-FXImage *new_FXImage(FXApp *a,VALUE ary,FXuint opts,FXint w,FXint h){
+FXImage *new_FXImage(FXApp *a,VALUE string_or_ary,FXuint opts,FXint w,FXint h){
       FXColor* pix=0;
-      if(!NIL_P(ary)){
-        Check_Type(ary,T_ARRAY);
-        if(FXMALLOC(&pix,FXColor,RARRAY_LEN(ary))){
-          for(long i=0; i<RARRAY_LEN(ary); i++){
-            pix[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(ary,i)));
-	    }
-          }
-	  opts&=IMAGE_OWNED;
+      if(!NIL_P(string_or_ary)){
+        FXuint len=FXRbNumberOfFXColors(string_or_ary);
+        if(w*h != len){
+          rb_raise( rb_eArgError, "Array size does not match image size" );
         }
-      return new FXRbImage(a,pix,opts,w,h);
+        pix=FXRbConvertToFXColors(string_or_ary);
+        opts|=IMAGE_OWNED;
       }
+      return new FXRbImage(a,pix,opts,w,h);
+    }
 FXMemoryBuffer *FXImage_getData(FXImage const *self){
       if(self->getData()){
         return new FXMemoryBuffer(self->getData(),self->getWidth()*self->getHeight());
-	}
+      }
       else{
         return 0;
-	}
+      }
+    }
+void FXImage_setPixels(FXImage *self,VALUE string_or_ary,FXuint opts,VALUE w,VALUE h){
+      FXuint len=FXRbNumberOfFXColors(string_or_ary);
+      if( ( (NIL_P(w) || NIL_P(h)) && self->getWidth()*self->getHeight() != len) ||
+          (!(NIL_P(w) || NIL_P(h)) && NUM2UINT(w)*NUM2UINT(h) != len)){
+        rb_raise( rb_eArgError, "Array size does not match image size" );
       }
 
+      FXColor* pix=FXRbConvertToFXColors(string_or_ary);
+      opts|=IMAGE_OWNED;
+      if( NIL_P(w) || NIL_P(h) ){
+        self->setData(pix,opts);
+      }else{
+        self->setData(pix,opts,NUM2UINT(w),NUM2UINT(h));
+      }
+    }
+VALUE FXImage_pixels(FXImage *self){
+      FXColor* data = self->getData();
+      if (data) {
+        FXuint size = self->getWidth()*self->getHeight();
+        VALUE ary = rb_ary_new2(size);
+        for (int i = 0; i < size; i++)
+          rb_ary_store(ary, i, UINT2NUM(data[i]));
+        return ary;
+      } else {
+        return Qnil;
+      }
+    }
+VALUE FXImage_pixel_string(FXImage *self){
+      FXColor* data = self->getData();
+      if (data) {
+        return rb_str_new((char*)data, self->getWidth()*self->getHeight()*sizeof(FXColor));
+      } else {
+        return Qnil;
+      }
+    }
+
 swig_class cFXImage;
 static void free_FXImage(FXImage *);
 
@@ -1204,35 +1238,20 @@ static VALUE _wrap_FXImage_setOptions(int argc, VALUE *argv, VALUE self) { FXIma
     if ((argc < 1) || (argc > 1)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXImage, 1); arg2 = NUM2UINT(argv[0]); (arg1)->setOptions(arg2);
     return Qnil; }
-static VALUE _wrap_FXImage_setData__SWIG_0(int argc, VALUE *argv, VALUE self) { FXImage *arg1 = (FXImage *) 0 ;
-    FXColor *arg2 = (FXColor *) 0 ; FXuint arg3 = (FXuint) 0 ; if ((argc < 1) || (argc > 2))
+static VALUE _wrap_FXImage_setPixels(int argc, VALUE *argv, VALUE self) { FXImage *arg1 = (FXImage *) 0 ; VALUE arg2 ;
+    FXuint arg3 = (FXuint) 0 ; VALUE arg4 = (VALUE) Qnil ; VALUE arg5 = (VALUE) Qnil ; if ((argc < 1) || (argc > 4))
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
-    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXImage, 1);
-    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_FXColor, 1); if (argc > 1) { arg3 = NUM2UINT(argv[1]); } 
-    (arg1)->setData(arg2,arg3); return Qnil; }
-static VALUE _wrap_FXImage_setData__SWIG_1(int argc, VALUE *argv, VALUE self) { FXImage *arg1 = (FXImage *) 0 ;
-    FXColor *arg2 = (FXColor *) 0 ; FXuint arg3 ; FXint arg4 ; FXint arg5 ; if ((argc < 4) || (argc > 4))
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
-    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXImage, 1);
-    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_FXColor, 1); arg3 = NUM2UINT(argv[1]); arg4 = NUM2INT(argv[2]);
-    arg5 = NUM2INT(argv[3]); (arg1)->setData(arg2,arg3,arg4,arg5); return Qnil; }
-static VALUE _wrap_FXImage_setData(int nargs, VALUE *args, VALUE self) { int argc; VALUE argv[6]; int ii; argc = nargs + 1;
-    argv[0] = self; for (ii = 1; (ii < argc) && (ii < 5); ii++) { argv[ii] = args[ii-1]; }  if ((argc >= 2) && (argc <= 3)) {
-        int _v; { void *ptr;
-            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_FXImage, 0) != -1)) ? 1 : 0; }
-         if (_v) { { void *ptr;
-                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_FXColor, 0) != -1)) ? 1 : 0; }
-             if (_v) { if (argc <= 2) { return _wrap_FXImage_setData__SWIG_0(nargs, args, self);}  {
-                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0; }  if (_v) {
-                    return _wrap_FXImage_setData__SWIG_0(nargs, args, self);}  }  }  }  if (argc == 5) { int _v; { void *ptr;
-            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_FXImage, 0) != -1)) ? 1 : 0; }
-         if (_v) { { void *ptr;
-                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_FXColor, 0) != -1)) ? 1 : 0; }
-             if (_v) { { _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0; }  if (_v) { {
-                        _v = ((TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0; }  if (_v) { {
-                            _v = ((TYPE(argv[4]) == T_FIXNUM) || (TYPE(argv[4]) == T_BIGNUM)) ? 1 : 0; }  if (_v) {
-                            return _wrap_FXImage_setData__SWIG_1(nargs, args, self);}  }  }  }  }  } 
-    rb_raise(rb_eArgError, "No matching function for overloaded 'FXImage_setData'"); return Qnil; }
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXImage, 1); arg2 = argv[0]; if (argc > 1) { arg3 = NUM2UINT(argv[1]); } 
+    if (argc > 2) { arg4 = argv[2]; }  if (argc > 3) { arg5 = argv[3]; }  FXImage_setPixels(arg1,arg2,arg3,arg4,arg5);
+    return Qnil; }
+static VALUE _wrap_FXImage_pixels(int argc, VALUE *argv, VALUE self) { FXImage *arg1 = (FXImage *) 0 ; VALUE result;
+    VALUE vresult = Qnil; if ((argc < 0) || (argc > 0)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXImage, 1); result = (VALUE)FXImage_pixels(arg1); vresult = result;
+    return vresult; }
+static VALUE _wrap_FXImage_pixel_string(int argc, VALUE *argv, VALUE self) { FXImage *arg1 = (FXImage *) 0 ; VALUE result;
+    VALUE vresult = Qnil; if ((argc < 0) || (argc > 0)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXImage, 1); result = (VALUE)FXImage_pixel_string(arg1); vresult = result;
+    return vresult; }
 static VALUE _wrap_FXImage_getPixel(int argc, VALUE *argv, VALUE self) { FXImage *arg1 = (FXImage *) 0 ; FXint arg2 ;
     FXint arg3 ; FXColor result; VALUE vresult = Qnil; if ((argc < 2) || (argc > 2))
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
@@ -3955,7 +3974,9 @@ SWIGEXPORT(void) Init_image(void) {
     rb_define_method(cFXImage.klass, "getData", VALUEFUNC(_wrap_FXImage_getData), -1);
     rb_define_method(cFXImage.klass, "getOptions", VALUEFUNC(_wrap_FXImage_getOptions), -1);
     rb_define_method(cFXImage.klass, "setOptions", VALUEFUNC(_wrap_FXImage_setOptions), -1);
-    rb_define_method(cFXImage.klass, "setData", VALUEFUNC(_wrap_FXImage_setData), -1);
+    rb_define_method(cFXImage.klass, "setPixels", VALUEFUNC(_wrap_FXImage_setPixels), -1);
+    rb_define_method(cFXImage.klass, "pixels", VALUEFUNC(_wrap_FXImage_pixels), -1);
+    rb_define_method(cFXImage.klass, "pixel_string", VALUEFUNC(_wrap_FXImage_pixel_string), -1);
     rb_define_method(cFXImage.klass, "getPixel", VALUEFUNC(_wrap_FXImage_getPixel), -1);
     rb_define_method(cFXImage.klass, "setPixel", VALUEFUNC(_wrap_FXImage_setPixel), -1);
     rb_define_method(cFXImage.klass, "hasAlpha?", VALUEFUNC(_wrap_FXImage_hasAlphaq___), -1);

data/ext/fox16/include/FXRuby.h

@@ -151,6 +151,12 @@ extern VALUE FXRbMakeArray(const FXSegment* segments,FXuint nsegments);
 // Returns a Ruby array of FXColor values
 extern VALUE FXRbMakeColorArray(const FXColor* colors,FXint w,FXint h);
 
+// Returns a number of FXColor elements in the argument
+extern FXuint FXRbNumberOfFXColors(VALUE string_or_ary);
+
+// Allocate a FXColor buffer and populate with data
+extern FXColor *FXRbConvertToFXColors(VALUE string_or_ary);
+
 extern void* FXRbGetExpectedData(VALUE recv,FXSelector key,VALUE data);
 
 // Returns the name of the message handler function (or NULL)

data/ext/fox16/librb.c

@@ -15,8 +15,8 @@
 #define SWIG_TypePrettyName  SWIG_Ruby_TypePrettyName
 #define SWIG_TypeQuery       SWIG_Ruby_TypeQuery
 #define SWIG_TypeClientData  SWIG_Ruby_TypeClientData
-#define SWIG_PackData        SWIG_Ruby_PackData
-#define SWIG_UnpackData      SWIG_Ruby_UnpackData
+#define SWIG_PackData        SWIG_Ruby_PackData 
+#define SWIG_UnpackData      SWIG_Ruby_UnpackData 
 
 /* Also rename all exported symbols from rubydef.swig */
 
@@ -55,7 +55,7 @@
  * Author : David Beazley (beazley@cs.uchicago.edu)
  *
  * Copyright (c) 1999-2000, The University of Chicago
- *
+ * 
  * This file may be freely redistributed without license or fee provided
  * this copyright message remains intact.
  ************************************************************************/
@@ -166,7 +166,7 @@ SWIG_TypeRegister(swig_type_info *ti) {
 }
 
 /* Check the typename */
-SWIGRUNTIME(swig_type_info *)
+SWIGRUNTIME(swig_type_info *) 
 SWIG_TypeCheck(char *c, swig_type_info *ty) {
   swig_type_info *s;
   if (!ty) return 0;        /* Void pointer */
@@ -192,14 +192,14 @@ SWIG_TypeCheck(char *c, swig_type_info *ty) {
 }
 
 /* Cast a pointer up an inheritance hierarchy */
-SWIGRUNTIME(void *)
+SWIGRUNTIME(void *) 
 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
   if ((!ty) || (!ty->converter)) return ptr;
   return (*ty->converter)(ptr);
 }
 
 /* Dynamic pointer casting. Down an inheritance hierarchy */
-SWIGRUNTIME(swig_type_info *)
+SWIGRUNTIME(swig_type_info *) 
 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
   swig_type_info *lastty = ty;
   if (!ty || !ty->dcast) return ty;
@@ -236,7 +236,7 @@ SWIG_TypePrettyName(const swig_type_info *type) {
     return type->name;
 }
 
-/*
+/* 
    Compare two type names skipping the space characters, therefore
    "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 
@@ -271,7 +271,7 @@ SWIG_TypeEquiv(const char *nb, const char *tb) {
   }
   return equiv;
 }
-
+  
 
 /* Search for a swig_type_info structure */
 SWIGRUNTIME(swig_type_info *)
@@ -405,7 +405,7 @@ SWIG_UnpackData(char *c, void *ptr, int sz) {
  * can be passed as an argument to API functions like Data_Wrap_Struct()
  * and Data_Make_Struct().
  */
-
+ 
 #ifdef __cplusplus
 #  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
 #    define PROTECTFUNC(f) ((VALUE (*)()) f)
@@ -503,10 +503,10 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int own)
     swig_class *sklass;
     VALUE klass;
     VALUE obj;
-
+    
     if (!ptr)
 	return Qnil;
-
+    
     if (type->clientdata) {
       sklass = (swig_class *) type->clientdata;
       obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
@@ -554,7 +554,7 @@ SWIG_Ruby_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags)
   } else {
     Data_Get_Struct(obj, void, *ptr);
   }
-
+  
   /* Do type-checking if type info was provided */
   if (ty) {
     if (ty->clientdata) {

data/ext/fox16/markfuncs.cpp

@@ -53,9 +53,16 @@ void FXRbObject::markfunc(FXObject* obj){
   FXTRACE((100,"%s::markfunc(%p)\n",obj?obj->getClassName():"FXRbObject",obj));
   }
 
-static void FXRbSetInGCRecursive(FXWindow *window, bool enabled){
+static void FXRbSetInGCParentsRecursive(FXWindow *window, bool enabled){
   FXRbSetInGC( window, true );
-  if(window->getParent()) FXRbSetInGCRecursive( window->getParent(), enabled );
+  if(window->getParent()) FXRbSetInGCParentsRecursive( window->getParent(), enabled );
+  }
+
+static void FXRbSetInGCChildrenRecursive(FXWindow *window, bool enabled){
+  FXRbSetInGC( window, true );
+  for(FXWindow* child=window->getFirst(); child; child=child->getNext()){
+    FXRbSetInGCChildrenRecursive( child, enabled );
+    }
   }
 
 
@@ -78,9 +85,9 @@ void FXRbObject::freefunc(FXObject* self){
       // The parent window should also be scheduled to be free'd. In the other case,
       // the child window would have been marked as used.
       if(self->isMemberOf(FXMETACLASS(FXWindow))){
-        if(FXWindow *parent = dynamic_cast<FXWindow*>(self)->getParent()){
-          FXRbSetInGCRecursive( parent, true );
-          }
+        FXWindow *window = dynamic_cast<FXWindow*>(self);
+        FXRbSetInGCParentsRecursive( window, true );
+        FXRbSetInGCChildrenRecursive( window, true );
         }
       delete self;
       }

data/lib/fox16/aliases.rb

@@ -147,6 +147,9 @@ module Fox
     def cursorWindow(*args) # :nodoc:
       getCursorWindow(*args)
     end
+    def modalWindow(*args) # :nodoc:
+      getModalWindow(*args)
+    end
     def modal?(*args) # :nodoc:
       isModal(*args)
     end
@@ -2411,6 +2414,9 @@ module Fox
     def data(*args) # :nodoc:
       getData(*args)
     end
+    def pixels=(*args) # :nodoc:
+      setPixels(*args)
+    end
     def options(*args) # :nodoc:
       getOptions(*args)
     end

data/lib/fox16/kwargs.rb

@@ -236,11 +236,11 @@ module Fox
     end
   end
 
-  class FXMenuButton
+  class FXSpring
     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{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 }
@@ -250,107 +250,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[:icon], params[:popupMenu], 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 FXToolBarTab
+  class FXTGAImage
     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, *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 FXBMPIcon
+  class FXColorItem
     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 }
+    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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(text, clr, params[:data], &blk)
     end
   end
 
-  class FXXBMIcon
+  class FXColorList
     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(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[:pixels], params[:mask], 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 FXMatrix
+  class FXApp
     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(*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 }
-      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(params[:appName], params[:vendorName], &blk)
     end
   end
 
-  class FXFontDialog
+  class FXColorBar
     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(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 }
       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, name, 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], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXTriStateButton
+  class FXTreeItem
     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(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 }
-      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, 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(text, params[:openIcon], params[:closedIcon], params[:data], &blk)
     end
   end
 
-  class FXToolBarGrip
+  class FXTreeList
     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 }
+      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 }
@@ -360,135 +356,123 @@ module Fox
     end
   end
 
-  class FXMainWindow
+  class FXInputDialog
     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(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(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(owner, caption, label, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXFileStream
+  class FXReplaceDialog
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{cont}
-      default_params = { :cont => 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(params[:cont], &blk)
+      old_initialize(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXHeaderItem
+  class FXScrollPane
     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(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 }
       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(owner, nvis, params[:opts], &blk)
     end
   end
 
-  class FXHeader
+  class FXMenuTitle
     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 }
+    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 }
-      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, text, params[:icon], params[:popupMenu], params[:opts], &blk)
     end
   end
 
-  class FXRGBImage
+  class FXFileStream
     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(*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(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(params[:cont], &blk)
     end
   end
 
-  class FXPopup
+  class FXStream
     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(*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, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(params[:cont], &blk)
     end
   end
 
-  class FXTextField
+  class FXFontDialog
     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(owner, name, *args, &blk)
+      argument_names = %w{opts x y width height}
+      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 }
-      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, 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(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXRGBIcon
+  class FXBMPImage
     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 FXTabItem
+  class FXTabBook
     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, *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 }
@@ -498,15 +482,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, 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, 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 FXTabBar
+  class FXSpinner
     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 => 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 => 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 }
@@ -516,61 +500,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], &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 FXToolBarShell
+  class FXMDIClient
     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, *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(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXProgressDialog
+  class FXColorSelector
     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(parent, *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(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXSeparator
+  class FXToolBarTab
     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 }
+      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], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXHorizontalSeparator
+  class FXDockTitle
     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{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 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -580,89 +560,97 @@ 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[: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 FXVerticalSeparator
+  class FXRGBIcon
     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 FXVisual
+  class FXCheckButton
     alias old_initialize initialize
-    def initialize(a, flgs, *args, &blk)
-      argument_names = %w{d}
-      default_params = { :d => 32 }
-      params = {}
+    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(a, flgs, params[:d], &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 FXMenuPane
+  class FXBitmapFrame
     alias old_initialize initialize
-    def initialize(owner, *args, &blk)
-      argument_names = %w{opts}
-      default_params = { :opts => 0 }
+    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 }
+      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(p, bmp, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXIconDict
+  class FXArrowButton
     alias old_initialize initialize
-    def initialize(app, *args, &blk)
-      argument_names = %w{path}
-      default_params = { :path => FXIconDict.defaultIconPath }
+    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 }
+      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[:path], &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 FXColorSelector
+  class FXXBMImage
     alias old_initialize initialize
-    def initialize(parent, *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(parent, 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 FXPicker
+  class FXComboBox
     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, 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 }
@@ -672,47 +660,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, 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, 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 FXColorWell
+  class FXFileItem
     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(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 }
-      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(text, params[:bi], params[:mi], params[:ptr], &blk)
     end
   end
 
-  class FXImageView
+  class FXFileList
     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 }
+      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[:img], 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 FXSpring
+  class FXPPMIcon
+    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 FXSwitcher
     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{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 }
@@ -722,57 +720,76 @@ 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[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXRulerView
+  class FXText
     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 => 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 }
+      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
+    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 FXListItem
+  class FXGIFImage
     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 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(text, params[:icon], params[:data], &blk)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXList
+  class FXSeparator
     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 }
+      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 }
+      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 FXDockSite
+  class FXHorizontalSeparator
     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 }
+      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 }
@@ -782,71 +799,79 @@ 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[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXJPGImage
+  class FXVerticalSeparator
     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{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 }
+      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[:opts], 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 FXJPGIcon
+  class FXRuler
     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 => 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 }
+      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 FXFontSelector
+  class FXFoldingItem
     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(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(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(text, params[:openIcon], params[:closedIcon], params[:data], &blk)
     end
   end
 
-  class FXXPMImage
+  class FXFoldingList
     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 => 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 }
       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 FXVerticalFrame
+  class FXDialogBox
     alias old_initialize initialize
-    def initialize(p, *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 => 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 }
+      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 }
@@ -856,33 +881,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], 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 FXOption
+  class FXRulerView
     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(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(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[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXOptionMenu
+  class FXScrollWindow
     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 }
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMainWindow
+    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 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -892,15 +927,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(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 FXToggleButton
+  class FXHorizontalFrame
     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(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 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -910,103 +945,107 @@ 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)
+      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 FXMDIChild
-    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 }
+  class FXScrollBar
+    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 }
       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 FXStream
+  class FXBitmapView
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{cont}
-      default_params = { :cont => 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(params[:cont], &blk)
+      old_initialize(p, params[:bmp], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXMDIClient
+  class FXColorRing
     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 }
+      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[: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 FXGIFImage
+  class FXButton
     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 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[: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 FXImage
+  class FXIconItem
     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(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(a, params[:pixels], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(text, params[:bigIcon], params[:miniIcon], params[:data], &blk)
     end
   end
 
-  class FXRealSpinner
+  class FXIconList
     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 => 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 }
-      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(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXWizard
+  class FXVerticalFrame
     alias old_initialize initialize
-    def initialize(owner, name, image, *args, &blk)
+    def initialize(p, *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 => 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 }
@@ -1016,47 +1055,39 @@ 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(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 FXComboBox
+  class FXProgressDialog
     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(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 }
-      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(owner, caption, label, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXRadioButton
+  class FXToolBarShell
     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(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(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(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
-  class FXTableItem
+  class FXListItem
     alias old_initialize initialize
     def initialize(text, *args, &blk)
       argument_names = %w{icon data}
@@ -1070,53 +1101,49 @@ module Fox
     end
   end
 
-  class FXTable
+  class FXList
     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 }
+      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 }
       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 FXPPMIcon
+  class FXXPMImage
     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 FXMenuSeparator
+  class FXRGBImage
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
-      argument_names = %w{opts}
-      default_params = { :opts => 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(parent, params[:opts], &blk)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXPCXIcon
+  class FXXPMIcon
     alias old_initialize initialize
     def initialize(a, *args, &blk)
       argument_names = %w{pix clr opts width height}
@@ -1130,169 +1157,189 @@ module Fox
     end
   end
 
-  class FXICOImage
+  class FXColorWell
     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, *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(a, params[:pix], params[:opts], params[:width], params[:height], &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 FXRegistry
+  class FXDockSite
     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{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 }
+      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[:appKey], params[:vendorKey], &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 FXPNGImage
+  class FXLabel
     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 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(a, params[:pix], params[:opts], params[:width], params[:height], &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 FXPacker
+  class FXTGAIcon
     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(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(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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXApp
+  class FXFontSelector
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{appName vendorName}
-      default_params = { :appName => "Application", :vendorName => "FoxDefault" }
+    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(params[:appName], params[:vendorName], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXMenuCascade
+  class FXDial
     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 => 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(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 FXTGAImage
+  class FXGIFCursor
     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(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 }
       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, pix, params[:hx], params[:hy], &blk)
     end
   end
 
-  class FXSplashWindow
+  class FXSlider
     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 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 }
       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, icon, params[:opts], params[:ms], &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 FXScrollPane
+  class FXTableItem
     alias old_initialize initialize
-    def initialize(owner, nvis, *args, &blk)
-      argument_names = %w{opts}
-      default_params = { :opts => 0 }
+    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(owner, nvis, params[:opts], &blk)
+      old_initialize(text, params[:icon], params[:data], &blk)
     end
   end
 
-  class FXColorItem
-    alias old_initialize initialize
-    def initialize(text, clr, *args, &blk)
-      argument_names = %w{data}
-      default_params = { :data => nil }
+  class FXTable
+    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 }
       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, clr, params[:data], &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 FXColorList
+  class FXPNGImage
     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 }
+    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 FXColorRing
+  class FXStatusBar
     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 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 }
@@ -1302,57 +1349,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, 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 FXIcon
+  class FXRegistry
     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(*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(app, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(params[:appKey], params[:vendorKey], &blk)
     end
   end
 
-  class FXPCXImage
+  class FXMatrix
     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, *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[:pix], 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 FXMessageBox
+  class FXWizard
     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 }
+    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(owner, caption, text, params[:ic], params[:opts], params[:x], params[:y], &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 FXDirBox
+  class FXGradientBar
     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 }
+      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 }
@@ -1366,109 +1421,113 @@ module Fox
     end
   end
 
-  class FXPrintDialog
+  class FXXBMIcon
     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(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 }
       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(a, params[:pixels], params[:mask], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXGLContext
+  class FXMenuPane
     alias old_initialize initialize
-    def initialize(app, visual, *args, &blk)
-      argument_names = %w{other}
-      default_params = { :other => nil }
+    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(app, visual, params[:other], &blk)
+      old_initialize(owner, params[:opts], &blk)
     end
   end
 
-  class FXXBMImage
+  class FXVisual
     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(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(a, params[:pixels], params[:mask], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(a, flgs, params[:d], &blk)
     end
   end
 
-  class FXFileSelector
+  class FXColorDialog
     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(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(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXTGAIcon
+  class FXMDIChild
     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, 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 }
       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, name, params[:ic], params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXToolTip
+  class FXPacker
     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(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 }
+      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[: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], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
-  class FXDirSelector
+  class FXMessageBox
     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(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[:target], params[:selector], 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 FXDialogBox
+  class FXShutterItem
     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(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 }
@@ -1478,61 +1537,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(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(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 FXDirDialog
+  class FXShutter
     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(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(owner, name, 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], params[:hSpacing], params[:vSpacing], &blk)
     end
   end
 
-  class FXRuler
+  class FXFileDict
     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(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 }
-      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[:db], &blk)
     end
   end
 
-  class FXBitmapView
+  class FXGIFIcon
     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 }
+    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(p, params[:bmp], params[:target], params[:selector], 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 FXText
+  class FXDriveBox
     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 }
+      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 }
@@ -1544,112 +1603,97 @@ 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 FXInputDialog
+  class FXScrollArea
     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(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(owner, caption, label, params[:icon], 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 FXXPMIcon
+  class FXICOImage
     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 FXICOIcon
+  class FXDirSelector
     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 => 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[: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 FXStatusLine
+  class FXToolBarGrip
     alias old_initialize initialize
     def initialize(p, *args, &blk)
-      argument_names = %w{target selector}
-      default_params = { :target => nil, :selector => 0 }
+      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], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXCanvas
+  class FXMDIDeleteButton
     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 => 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(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 FXRealSlider
+  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 => REALSLIDER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+      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 FXScrollBar
+  class FXMDIMaximizeButton
     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 }
+      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 }
@@ -1659,157 +1703,137 @@ module Fox
     end
   end
 
-  class FXSwitcher
+  class FXMDIMinimizeButton
     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 }
+      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], &blk)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXDockTitle
+  class FXMDIWindowButton
     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(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 }
-      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(p, pup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXColorDialog
+  class FXMDIMenu
     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(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(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(owner, params[:target], &blk)
     end
   end
 
-  class FXMemoryStream
+  class FXTIFIcon
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{cont}
-      default_params = { :cont => 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(params[:cont], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXProgressBar
+  class FXDirItem
     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(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 }
-      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(text, params[:oi], params[:ci], params[:data], &blk)
     end
   end
 
-  class FXMenuRadio
+  class FXDirList
     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}
+      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, 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], &blk)
     end
   end
 
-  class FXGradientBar
+  class FXPCXImage
     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 }
+    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[: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 FXGIFIcon
+  class FXCanvas
     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, *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(a, params[:pix], params[:clr], params[:opts], 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 FXKnob
+  class FXDataTarget
     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 }
+    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 }
-      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(params[:value], params[:target], params[:selector], &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 }
@@ -1823,99 +1847,103 @@ module Fox
     end
   end
 
-  class FXBitmap
+  class FXPCXIcon
     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(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(app, params[:pixels], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXIconItem
+  class FXToggleButton
     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(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 }
+      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(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 FXIconList
+  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 => ICONLIST_NORMAL, :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 FXBMPImage
+  class FXToolTip
     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(app, *args, &blk)
+      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(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(app, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXSearchDialog
+  class FXMenuCaption
     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(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(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(parent, text, params[:icon], params[:opts], &blk)
     end
   end
 
-  class FXTabBook
+  class FXBitmap
     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(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 }
-      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[:pixels], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXBitmapFrame
+  class FX7Segment
     alias old_initialize initialize
-    def initialize(p, bmp, *args, &blk)
+    def initialize(p, text, *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 }
+      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 }
@@ -1925,33 +1953,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, bmp, 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 FXLabel
+  class FXPopup
     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 }
+    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 }
-      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)
+      old_initialize(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXGroupBox
+  class FXListBox
     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 }
+    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 }
@@ -1961,21 +1985,7 @@ 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[: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 FXPPMImage
-    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)
+      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
 
@@ -1993,47 +2003,39 @@ module Fox
     end
   end
 
-  class FXSlider
+  class FXMenuCascade
     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, 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 }
-      if params.key? :padding
-        value = params.delete(:padding)
-        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
-      end
+      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], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], &blk)
     end
   end
 
-  class FXShutterItem
+  class FXPPMImage
     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 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[: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[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXShutter
+  class FXTextField
     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 }
+    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 }
@@ -2043,33 +2045,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], 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 FXImageFrame
+  class FXHeaderItem
     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(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 }
-      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, img, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+      old_initialize(text, params[:ic], params[:s], params[:ptr], &blk)
     end
   end
 
-  class FXTreeListBox
+  class FXHeader
     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 }
+      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 }
@@ -2083,101 +2081,97 @@ module Fox
     end
   end
 
-  class FXReplaceDialog
+  class FXDelegator
     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(*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(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(params[:delegate], &blk)
     end
   end
 
-  class FXMenuCaption
+  class FXDirDialog
     alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
-      argument_names = %w{icon opts}
-      default_params = { :icon => nil, :opts => 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(parent, text, params[:icon], params[:opts], &blk)
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXScintilla
+  class FXRealSpinner
     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(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 }
       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, 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 FXHorizontalFrame
+  class FXFileDialog
     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 }
+    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(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(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXTIFImage
+  class FXIconDict
     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(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 }
       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(app, params[:path], &blk)
     end
   end
 
-  class FXColorBar
+  class FXScintilla
     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(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[: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 FXPNGIcon
+  class FXIcon
     alias old_initialize initialize
-    def initialize(a, *args, &blk)
+    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 = {}
@@ -2185,65 +2179,57 @@ 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(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+      old_initialize(app, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXButton
+  class FXJPGIcon
     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(a, *args, &blk)
+      argument_names = %w{pix clr opts width height quality}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1, :quality => 75 }
       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[: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], params[:quality], &blk)
     end
   end
 
-  class FXColorWheel
+  class FXMenuRadio
     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 }
+    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 }
-      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, text, params[:target], params[:selector], params[:opts], &blk)
     end
   end
 
-  class FXMenuCommand
+  class FXBMPIcon
     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(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, text, params[:ic], params[:target], params[:selector], params[:opts], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXDial
+  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 => DIAL_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 => 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 }
@@ -2253,29 +2239,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, 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 FXDataTarget
+  class FXChoiceBox
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{value target selector}
-      default_params = { :value => nil, :target => nil, :selector => 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 }
       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(owner, caption, text, icon, choices, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXArrowButton
+  class FXDirBox
     alias old_initialize initialize
-    def initialize(parent, *args, &blk)
+    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 => ARROW_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_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 }
@@ -2285,117 +2271,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, 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 FXStatusBar
+  class FXICOIcon
     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(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], params[:hSpacing], params[:vSpacing], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXTreeItem
+  class FXPNGIcon
     alias old_initialize initialize
-    def initialize(text, *args, &blk)
-      argument_names = %w{openIcon closedIcon data}
-      default_params = { :openIcon => nil, :closedIcon => 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[:openIcon], params[:closedIcon], params[:data], &blk)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXTreeList
+  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 => 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 }
-      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 FXFoldingItem
-    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{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(text, params[:openIcon], params[:closedIcon], params[:data], &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 FXFoldingList
+  class FXImageView
     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 }
+      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(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(p, params[:img], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
     end
   end
 
-  class FXFileItem
+  class FXStatusLine
     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}
+      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(text, params[:bi], params[:mi], params[:ptr], &blk)
+      old_initialize(p, params[:target], params[:selector], &blk)
     end
   end
 
-  class FXFileList
+  class FXSearchDialog
     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(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(p, params[:target], params[:selector], 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 FXCheckButton
+  class FXProgressBar
     alias old_initialize initialize
-    def initialize(parent, text, *args, &blk)
+    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 => 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 => 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 }
@@ -2405,181 +2377,205 @@ 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, 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 FXMDIDeleteButton
+  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 => FRAME_RAISED, :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 FXMDIRestoreButton
+  class FXSplashWindow
     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(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(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      old_initialize(owner, icon, params[:opts], params[:ms], &blk)
     end
   end
 
-  class FXMDIMaximizeButton
+  class FXMenuCommand
     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(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(p, params[:target], params[:selector], 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 FXMDIMinimizeButton
+  class FXTabItem
     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(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 }
+      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, 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 FXMDIWindowButton
+  class FXColorWheel
     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(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 }
       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, pup, 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 FXMDIMenu
+  class FXMemoryStream
     alias old_initialize initialize
-    def initialize(owner, *args, &blk)
-      argument_names = %w{target}
-      default_params = { :target => nil }
+    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, params[:target], &blk)
+      old_initialize(params[:cont], &blk)
     end
   end
 
-  class FXScrollWindow
+  class FXImageFrame
     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(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(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &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 FXGIFCursor
+  class FXImage
     alias old_initialize initialize
-    def initialize(a, pix, *args, &blk)
-      argument_names = %w{hx hy}
-      default_params = { :hx => -1, :hy => -1 }
+    def initialize(a, *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(a, pix, params[:hx], params[:hy], &blk)
+      old_initialize(a, params[:pixels], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXScrollArea
+  class FXTriStateButton
     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, 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(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], &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 FXFileDialog
+  class FXJPGImage
     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(a, *args, &blk)
+      argument_names = %w{pix opts width height quality}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1, :quality => 75 }
       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(a, params[:pix], params[:opts], params[:width], params[:height], params[:quality], &blk)
     end
   end
 
-  class FXComposite
+  class FXKnob
     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{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(parent, 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 FXMenuTitle
+  class FXTreeListBox
     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 => 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(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 FXChoiceBox
+  class FXPrintDialog
     alias old_initialize initialize
-    def initialize(owner, caption, text, icon, choices, *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 = {}
@@ -2587,29 +2583,29 @@ 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(owner, caption, text, icon, choices, 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 FXDelegator
+  class FXTIFImage
     alias old_initialize initialize
-    def initialize(*args, &blk)
-      argument_names = %w{delegate}
-      default_params = { :delegate => nil }
+    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(params[:delegate], &blk)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
     end
   end
 
-  class FXFrame
+  class FXRadioButton
     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(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 }
@@ -2619,57 +2615,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(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &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 FXTIFIcon
+  class FXFileSelector
     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 => 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[: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 FXDirItem
+  class FXMenuSeparator
     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(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 }
       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(parent, params[:opts], &blk)
     end
   end
 
-  class FXDirList
+  class FXGroupBox
     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{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(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &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 FX7Segment
+  class FXMenuButton
     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(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 }
       params = {}
       params = args.pop if args.last.is_a? Hash
       args.each_with_index { |e, i| params[argument_names[i].intern] = e }
@@ -2679,29 +2679,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, text, 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[:popupMenu], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end
 
-  class FXFileDict
+  class FXGLContext
     alias old_initialize initialize
-    def initialize(app, *args, &blk)
-      argument_names = %w{db}
-      default_params = { :db => nil }
+    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_initialize(app, params[:db], &blk)
+      old_initialize(app, visual, params[:other], &blk)
     end
   end
 
-  class FXSpinner
+  class FXOption
     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(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 }
@@ -2711,15 +2711,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, 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, 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 FXListBox
+  class FXOptionMenu
     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 }
+      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 }
@@ -2729,7 +2729,7 @@ 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[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
     end
   end