fxruby 1.6.2 → 1.6.3

data/ext/fox16/frames_wrap.cpp

@@ -662,8 +662,8 @@ VALUE FXDial_getRange(FXDial const *self){
 
 swig_class cFXDial;
 static void free_FXDial(FXDial *);
-FXHeaderItem *new_FXHeaderItem(FXString const &text,FXIcon *ic,FXint s,void *ptr){
-      return new FXRbHeaderItem(text,ic,s,ptr);
+FXHeaderItem *new_FXHeaderItem(FXString const &text,FXIcon *ic,FXint s,void *ITEMDATA){
+      return new FXRbHeaderItem(text,ic,s,ITEMDATA);
       }
 void FXHeaderItem_setData(FXHeaderItem *self,VALUE ptr){
       self->setData((void*) ptr);
@@ -2956,7 +2956,7 @@ static VALUE _wrap_new_FXHeaderItem(int argc, VALUE *argv, VALUE self) { FXStrin
     FXint arg3 = (FXint) 0 ; void *arg4 = (void *) 0 ; FXHeaderItem *result; SwigValueWrapper<FXString > p1 ;
     if ((argc < 1) || (argc > 4)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
     p1 = to_FXString(argv[0]); arg1 = &p1; if (argc > 1) { SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXIcon, 1); } 
-    if (argc > 2) { arg3 = NUM2INT(argv[2]); }  if (argc > 3) { SWIG_ConvertPtr(argv[3], (void **) &arg4, 0, 1); }  {
+    if (argc > 2) { arg3 = NUM2INT(argv[2]); }  if (argc > 3) { arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3]; }  {
         result = (FXHeaderItem *)new_FXHeaderItem((FXString const &)*arg1,arg2,arg3,arg4);
         DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
 static VALUE _wrap_FXHeaderItem_getText(int argc, VALUE *argv, VALUE self) { FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;

data/ext/fox16/iconlist_wrap.cpp

@@ -597,8 +597,8 @@ inline void* to_FXEvent(VALUE obj){
   return ptr;
   }
 
-FXIconItem *new_FXIconItem(FXString const &text,FXIcon *bi,FXIcon *mi,void *ptr){
-      return new FXRbIconItem(text,bi,mi,ptr);
+FXIconItem *new_FXIconItem(FXString const &text,FXIcon *bi,FXIcon *mi,void *ITEMDATA){
+      return new FXRbIconItem(text,bi,mi,ITEMDATA);
       }
 void FXIconItem_setData(FXIconItem *self,VALUE ptr){
       self->setData((void*) ptr);
@@ -725,8 +725,8 @@ static swig_type_info *FXIconList_dynamic_cast(void **ptr) {
     return 0;
 }
 
-FXFileItem *new_FXFileItem(FXString const &text,FXIcon *bi,FXIcon *mi,void *ptr){
-      return new FXRbFileItem(text,bi,mi,ptr);
+FXFileItem *new_FXFileItem(FXString const &text,FXIcon *bi,FXIcon *mi,void *ITEMDATA){
+      return new FXRbFileItem(text,bi,mi,ITEMDATA);
       }
 
 swig_class cFXFileItem;
@@ -760,7 +760,7 @@ static VALUE _wrap_new_FXIconItem(int argc, VALUE *argv, VALUE self) { FXString
     if ((argc < 1) || (argc > 4)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
     p1 = to_FXString(argv[0]); arg1 = &p1; if (argc > 1) { SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXIcon, 1); } 
     if (argc > 2) { SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXIcon, 1); }  if (argc > 3) {
-        SWIG_ConvertPtr(argv[3], (void **) &arg4, 0, 1); }  {
+        arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3]; }  {
         result = (FXIconItem *)new_FXIconItem((FXString const &)*arg1,arg2,arg3,arg4);
         DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
 static VALUE _wrap_FXIconItem_getText(int argc, VALUE *argv, VALUE self) { FXIconItem *arg1 = (FXIconItem *) 0 ;
@@ -2016,7 +2016,7 @@ static VALUE _wrap_new_FXFileItem(int argc, VALUE *argv, VALUE self) { FXString
     if ((argc < 1) || (argc > 4)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
     p1 = to_FXString(argv[0]); arg1 = &p1; if (argc > 1) { SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXIcon, 1); } 
     if (argc > 2) { SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXIcon, 1); }  if (argc > 3) {
-        SWIG_ConvertPtr(argv[3], (void **) &arg4, 0, 1); }  {
+        arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3]; }  {
         result = (FXFileItem *)new_FXFileItem((FXString const &)*arg1,arg2,arg3,arg4);
         DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
 static VALUE _wrap_FXFileItem_isFile(int argc, VALUE *argv, VALUE self) { FXFileItem *arg1 = (FXFileItem *) 0 ; FXbool result;

data/ext/fox16/list_wrap.cpp

@@ -595,8 +595,8 @@ inline void* to_FXEvent(VALUE obj){
   return ptr;
   }
 
-FXListItem *new_FXListItem(FXString const &text,FXIcon *ic,void *ptr){
-      return new FXRbListItem(text,ic,ptr);
+FXListItem *new_FXListItem(FXString const &text,FXIcon *ic,void *ITEMDATA){
+      return new FXRbListItem(text,ic,ITEMDATA);
       }
 void FXListItem_setData(FXListItem *self,VALUE ptr){
       self->setData((void*) ptr);
@@ -722,8 +722,8 @@ static swig_type_info *FXList_dynamic_cast(void **ptr) {
     return 0;
 }
 
-FXColorItem *new_FXColorItem(FXString const &text,FXColor clr,void *ptr){
-      return new FXRbColorItem(text,clr,ptr);
+FXColorItem *new_FXColorItem(FXString const &text,FXColor clr,void *ITEMDATA){
+      return new FXRbColorItem(text,clr,ITEMDATA);
       }
 
 swig_class cFXColorItem;
@@ -756,7 +756,7 @@ static VALUE _wrap_new_FXListItem(int argc, VALUE *argv, VALUE self) { FXString
     void *arg3 = (void *) 0 ; FXListItem *result; SwigValueWrapper<FXString > p1 ; if ((argc < 1) || (argc > 3))
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); p1 = to_FXString(argv[0]); arg1 = &p1; if (argc > 1) {
         SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXIcon, 1); }  if (argc > 2) {
-        SWIG_ConvertPtr(argv[2], (void **) &arg3, 0, 1); }  {
+        arg3 = (argv[2] == Qnil) ? NULL : (void *) argv[2]; }  {
         result = (FXListItem *)new_FXListItem((FXString const &)*arg1,arg2,arg3);
         DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
 static VALUE _wrap_FXListItem_getText(int argc, VALUE *argv, VALUE self) { FXListItem *arg1 = (FXListItem *) 0 ;
@@ -1704,7 +1704,7 @@ static VALUE _wrap_FXColorItem_allocate(VALUE self) {
 static VALUE _wrap_new_FXColorItem(int argc, VALUE *argv, VALUE self) { FXString *arg1 = 0 ; FXColor arg2 ;
     void *arg3 = (void *) 0 ; FXColorItem *result; SwigValueWrapper<FXString > p1 ; if ((argc < 2) || (argc > 3))
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); p1 = to_FXString(argv[0]); arg1 = &p1;
-    arg2 = to_FXColor(argv[1]); if (argc > 2) { SWIG_ConvertPtr(argv[2], (void **) &arg3, 0, 1); }  {
+    arg2 = to_FXColor(argv[1]); if (argc > 2) { arg3 = (argv[2] == Qnil) ? NULL : (void *) argv[2]; }  {
         result = (FXColorItem *)new_FXColorItem((FXString const &)*arg1,arg2,arg3);
         DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
 static VALUE _wrap_FXColorItem_colore___(int argc, VALUE *argv, VALUE self) { FXColorItem *arg1 = (FXColorItem *) 0 ;
@@ -1811,7 +1811,7 @@ static VALUE _wrap_FXColorList_fillItems(int argc, VALUE *argv, VALUE self) { FX
                 Check_Type(argv[1], T_ARRAY); if (FXMALLOC(&arg3, FXColor, RARRAY(argv[1])->len)+1) {
                     for (long i = 0; i < RARRAY(argv[1])->len; i++) {
                         arg3[i] = static_cast<FXColor>(NUM2ULONG(rb_ary_entry(argv[1], i))); }  arg3[RARRAY(argv[1])->len] = 0; }
-                 }  }  }  if (argc > 2) { SWIG_ConvertPtr(argv[2], (void **) &arg4, 0, 1); }  if (argc > 3) {
+                 }  }  }  if (argc > 2) { arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2]; }  if (argc > 3) {
         arg5 = to_FXbool(argv[3]); }  result = (FXint)(arg1)->fillItems((FXchar const **)arg2,arg3,arg4,arg5);
     vresult = INT2NUM(result); FXFREE(&arg2); FXFREE(&arg3); return vresult; }
 static VALUE _wrap_FXColorList_insertItem(int argc, VALUE *argv, VALUE self) { FXColorList *arg1 = (FXColorList *) 0 ;
@@ -1820,14 +1820,14 @@ static VALUE _wrap_FXColorList_insertItem(int argc, VALUE *argv, VALUE self) { F
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXColorList, 1); arg2 = NUM2INT(argv[0]);
     p3 = to_FXString(argv[1]); arg3 = &p3; if (argc > 2) { arg4 = to_FXColor(argv[2]); }  if (argc > 3) {
-        SWIG_ConvertPtr(argv[3], (void **) &arg5, 0, 1); }  if (argc > 4) { arg6 = to_FXbool(argv[4]); } 
+        arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3]; }  if (argc > 4) { arg6 = to_FXbool(argv[4]); } 
     result = (FXint)(arg1)->insertItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6); vresult = INT2NUM(result); return vresult; }
 static VALUE _wrap_FXColorList_appendItem(int argc, VALUE *argv, VALUE self) { FXColorList *arg1 = (FXColorList *) 0 ;
     FXString *arg2 = 0 ; FXColor arg3 = (FXColor) 0 ; void *arg4 = (void *) 0 ; FXbool arg5 = (FXbool) 0 ; FXint result;
     SwigValueWrapper<FXString > p2 ; VALUE vresult = Qnil; if ((argc < 1) || (argc > 4))
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXColorList, 1); p2 = to_FXString(argv[0]); arg2 = &p2; if (argc > 1) {
-        arg3 = to_FXColor(argv[1]); }  if (argc > 2) { SWIG_ConvertPtr(argv[2], (void **) &arg4, 0, 1); }  if (argc > 3) {
+        arg3 = to_FXColor(argv[1]); }  if (argc > 2) { arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2]; }  if (argc > 3) {
         arg5 = to_FXbool(argv[3]); }  result = (FXint)(arg1)->appendItem((FXString const &)*arg2,arg3,arg4,arg5);
     vresult = INT2NUM(result); return vresult; }
 static VALUE _wrap_FXColorList_prependItem(int argc, VALUE *argv, VALUE self) { FXColorList *arg1 = (FXColorList *) 0 ;
@@ -1835,7 +1835,7 @@ static VALUE _wrap_FXColorList_prependItem(int argc, VALUE *argv, VALUE self) {
     SwigValueWrapper<FXString > p2 ; VALUE vresult = Qnil; if ((argc < 1) || (argc > 4))
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXColorList, 1); p2 = to_FXString(argv[0]); arg2 = &p2; if (argc > 1) {
-        arg3 = to_FXColor(argv[1]); }  if (argc > 2) { SWIG_ConvertPtr(argv[2], (void **) &arg4, 0, 1); }  if (argc > 3) {
+        arg3 = to_FXColor(argv[1]); }  if (argc > 2) { arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2]; }  if (argc > 3) {
         arg5 = to_FXbool(argv[3]); }  result = (FXint)(arg1)->prependItem((FXString const &)*arg2,arg3,arg4,arg5);
     vresult = INT2NUM(result); return vresult; }
 static VALUE _wrap_FXColorList_setItemColor(int argc, VALUE *argv, VALUE self) { FXColorList *arg1 = (FXColorList *) 0 ;

data/ext/fox16/mdi_wrap.cpp

@@ -2162,14 +2162,14 @@ static VALUE _wrap_FXMDIClient_forallWindows(int argc, VALUE *argv, VALUE self)
     if ((argc < 3) || (argc > 3)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXMDIClient, 1);
     SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_FXObject, 1); arg3 = NUM2UINT(argv[1]);
-    SWIG_ConvertPtr(argv[2], (void **) &arg4, 0, 1); result = (long)(arg1)->forallWindows(arg2,arg3,arg4);
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2]; result = (long)(arg1)->forallWindows(arg2,arg3,arg4);
     vresult = INT2NUM(result); return vresult; }
 static VALUE _wrap_FXMDIClient_forallDocuments(int argc, VALUE *argv, VALUE self) { FXMDIClient *arg1 = (FXMDIClient *) 0 ;
     FXObject *arg2 = (FXObject *) 0 ; FXSelector arg3 ; void *arg4 = (void *) 0 ; long result; VALUE vresult = Qnil;
     if ((argc < 3) || (argc > 3)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXMDIClient, 1);
     SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_FXObject, 1); arg3 = NUM2UINT(argv[1]);
-    SWIG_ConvertPtr(argv[2], (void **) &arg4, 0, 1); result = (long)(arg1)->forallDocuments(arg2,arg3,arg4);
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2]; result = (long)(arg1)->forallDocuments(arg2,arg3,arg4);
     vresult = INT2NUM(result); return vresult; }
 static VALUE _wrap_FXMDIClient_forallDocWindows(int argc, VALUE *argv, VALUE self) { FXMDIClient *arg1 = (FXMDIClient *) 0 ;
     FXObject *arg2 = (FXObject *) 0 ; FXObject *arg3 = (FXObject *) 0 ; FXSelector arg4 ; void *arg5 = (void *) 0 ; long result;
@@ -2177,7 +2177,7 @@ static VALUE _wrap_FXMDIClient_forallDocWindows(int argc, VALUE *argv, VALUE sel
     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXMDIClient, 1);
     SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_FXObject, 1);
     SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_FXObject, 1); arg4 = NUM2UINT(argv[2]);
-    SWIG_ConvertPtr(argv[3], (void **) &arg5, 0, 1); result = (long)(arg1)->forallDocWindows(arg2,arg3,arg4,arg5);
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3]; result = (long)(arg1)->forallDocWindows(arg2,arg3,arg4,arg5);
     vresult = INT2NUM(result); return vresult; }
 static VALUE _wrap_FXMDIClient_getActiveChild(int argc, VALUE *argv, VALUE self) { FXMDIClient *arg1 = (FXMDIClient *) 0 ;
     FXMDIChild *result; VALUE vresult = Qnil; if ((argc < 0) || (argc > 0))

data/ext/fox16/treelist_wrap.cpp

@@ -599,8 +599,8 @@ inline void* to_FXEvent(VALUE obj){
   return ptr;
   }
 
-FXFoldingItem *new_FXFoldingItem(FXString const &text,FXIcon *oi,FXIcon *ci,void *ptr){
-      return new FXRbFoldingItem(text,oi,ci,ptr);
+FXFoldingItem *new_FXFoldingItem(FXString const &text,FXIcon *oi,FXIcon *ci,void *ITEMDATA){
+      return new FXRbFoldingItem(text,oi,ci,ITEMDATA);
       }
 void FXFoldingItem_setData(FXFoldingItem *self,VALUE ptr){
       self->setData(reinterpret_cast<void*>(ptr));
@@ -704,8 +704,8 @@ VALUE FXFoldingList_position__SWIG_1(FXFoldingList const *self){
 
 swig_class cFXFoldingList;
 static void free_FXFoldingList(FXFoldingList *);
-FXTreeItem *new_FXTreeItem(FXString const &text,FXIcon *oi,FXIcon *ci,void *ptr){
-      return new FXRbTreeItem(text,oi,ci,ptr);
+FXTreeItem *new_FXTreeItem(FXString const &text,FXIcon *oi,FXIcon *ci,void *ITEMDATA){
+      return new FXRbTreeItem(text,oi,ci,ITEMDATA);
       }
 void FXTreeItem_setData(FXTreeItem *self,VALUE ptr){
       self->setData((void*) ptr);
@@ -836,8 +836,8 @@ static swig_type_info *FXTreeList_dynamic_cast(void **ptr) {
     return 0;
 }
 
-FXDirItem *new_FXDirItem(FXString const &text,FXIcon *oi,FXIcon *ci,void *ptr){
-      return new FXRbDirItem(text,oi,ci,ptr);
+FXDirItem *new_FXDirItem(FXString const &text,FXIcon *oi,FXIcon *ci,void *ITEMDATA){
+      return new FXRbDirItem(text,oi,ci,ITEMDATA);
       }
 
 swig_class cFXDirItem;
@@ -871,7 +871,7 @@ static VALUE _wrap_new_FXFoldingItem(int argc, VALUE *argv, VALUE self) { FXStri
     if ((argc < 1) || (argc > 4)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
     p1 = to_FXString(argv[0]); arg1 = &p1; if (argc > 1) { SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXIcon, 1); } 
     if (argc > 2) { SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXIcon, 1); }  if (argc > 3) {
-        SWIG_ConvertPtr(argv[3], (void **) &arg4, 0, 1); }  {
+        arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3]; }  {
         result = (FXFoldingItem *)new_FXFoldingItem((FXString const &)*arg1,arg2,arg3,arg4);
         DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
 static VALUE _wrap_FXFoldingItem_getParent(int argc, VALUE *argv, VALUE self) { FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
@@ -2161,7 +2161,7 @@ static VALUE _wrap_new_FXTreeItem(int argc, VALUE *argv, VALUE self) { FXString
     if ((argc < 1) || (argc > 4)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
     p1 = to_FXString(argv[0]); arg1 = &p1; if (argc > 1) { SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXIcon, 1); } 
     if (argc > 2) { SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXIcon, 1); }  if (argc > 3) {
-        SWIG_ConvertPtr(argv[3], (void **) &arg4, 0, 1); }  {
+        arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3]; }  {
         result = (FXTreeItem *)new_FXTreeItem((FXString const &)*arg1,arg2,arg3,arg4);
         DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
 static VALUE _wrap_FXTreeItem_getText(int argc, VALUE *argv, VALUE self) { FXTreeItem *arg1 = (FXTreeItem *) 0 ;
@@ -3353,7 +3353,7 @@ static VALUE _wrap_new_FXDirItem(int argc, VALUE *argv, VALUE self) { FXString *
     if ((argc < 1) || (argc > 4)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
     p1 = to_FXString(argv[0]); arg1 = &p1; if (argc > 1) { SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXIcon, 1); } 
     if (argc > 2) { SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXIcon, 1); }  if (argc > 3) {
-        SWIG_ConvertPtr(argv[3], (void **) &arg4, 0, 1); }  {
+        arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3]; }  {
         result = (FXDirItem *)new_FXDirItem((FXString const &)*arg1,arg2,arg3,arg4);
         DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
 static VALUE _wrap_FXDirItem_isFile(int argc, VALUE *argv, VALUE self) { FXDirItem *arg1 = (FXDirItem *) 0 ; FXbool result;

data/ext/fox16/ui_wrap.cpp

@@ -5386,8 +5386,9 @@ static VALUE _wrap_FXListBox_fillItems(int argc, VALUE *argv, VALUE self) { FXLi
                 for (long i = 0; i < RARRAY(argv[0])->len; i++) { arg2[i] = (FXchar *) STR2CSTR(rb_ary_entry(argv[0], i)); } 
                 arg2[RARRAY(argv[0])->len] = 0; }  }  }  if (argc > 1) {
         SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_FXIcon, 1); }  if (argc > 2) {
-        SWIG_ConvertPtr(argv[2], (void **) &arg4, 0, 1); }  result = (FXint)(arg1)->fillItems((FXchar const **)arg2,arg3,arg4);
-    vresult = INT2NUM(result); FXFREE(&arg2); return vresult; }
+        arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2]; } 
+    result = (FXint)(arg1)->fillItems((FXchar const **)arg2,arg3,arg4); vresult = INT2NUM(result); FXFREE(&arg2);
+    return vresult; }
 static VALUE _wrap_FXListBox_insertItem(int argc, VALUE *argv, VALUE self) { FXListBox *arg1 = (FXListBox *) 0 ; FXint arg2 ;
     FXString *arg3 = 0 ; FXIcon *arg4 = (FXIcon *) 0 ; void *arg5 = (void *) 0 ; FXint result; SwigValueWrapper<FXString > p3 ;
     VALUE vresult = Qnil; if ((argc < 2) || (argc > 4)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);

data/lib/fox16/aliases.rb

@@ -4291,6 +4291,21 @@ module Fox
     end
   end
   class FXTable
+    def itemVisible?(*args) # :nodoc:
+      isItemVisible(*args)
+    end
+    def itemSpanning?(*args) # :nodoc:
+      isItemSpanning(*args)
+    end
+    def itemEnabled?(*args) # :nodoc:
+      isItemEnabled(*args)
+    end
+    def itemCurrent?(*args) # :nodoc:
+      isItemCurrent(*args)
+    end
+    def itemSelected?(*args) # :nodoc:
+      isItemSelected(*args)
+    end
     def horizontalGridShown=(vis) # :nodoc:
       showHorzGrid(vis)
     end

data/lib/fox16/core.rb

@@ -451,6 +451,11 @@ module Fox
                              table.marginLeft, table.marginRight,
 			     table.marginTop, table.marginBottom)
       combo.create
+      justify = 0
+      justify |= JUSTIFY_LEFT   if (self.justify & FXTableItem::LEFT) != 0
+      justify |= JUSTIFY_RIGHT  if (self.justify & FXTableItem::RIGHT) != 0
+      justify |= JUSTIFY_TOP    if (self.justify & FXTableItem::TOP) != 0
+      justify |= JUSTIFY_BOTTOM if (self.justify & FXTableItem::BOTTOM) != 0
       combo.justify = justify
       combo.font = table.font
       combo.backColor = table.backColor
@@ -458,7 +463,7 @@ module Fox
       combo.selBackColor = table.selBackColor
       combo.selTextColor = table.selTextColor
       combo.fillItems(selections)
-      combo.text = label
+      combo.text = text
       combo.numVisible = [20, combo.numItems].min
       combo
     end

data/lib/fox16/iterators.rb

@@ -90,9 +90,9 @@ module Fox
     # references (one element per column) as a parameter.
     #
     def each_row # :yields: itemArray
-      0.upto(getNumRows - 1) do |i|
+      0.upto(numRows - 1) do |i|
         tableRow = []
-        0.upto(getNumCols - 1) do |j|
+        0.upto(numColumns - 1) do |j|
           tableRow << getItem(i, j)
         end
         yield tableRow
@@ -105,9 +105,9 @@ module Fox
     # references (one element per row) as a parameter.
     #
     def each_column # :yields: itemArray
-      0.upto(getNumCols - 1) do |j|
+      0.upto(numColumns - 1) do |j|
         tableCol = []
-        0.upto(getNumRows - 1) do |i|
+        0.upto(numRows - 1) do |i|
           tableCol << getItem(i, j)
         end
         yield tableCol

data/lib/fox16/kwargs.rb

@@ -0,0 +1,2292 @@
+require 'fox16'
+
+module Fox
+
+
+  class FX4Splitter
+    alias old_initialize initialize
+    def initialize(*args)
+      default_params = { :opts => FOURSPLITTER_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0 }     
+      case args.length
+      when 1,2
+        params = (args.length == 2) ? args[1] : {}
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], params[:opts], params[:x], params[:y], params[:w], params[:h])
+      when 3,4
+        params = (args.length == 4) ? args[3] : {}
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], args[1], args[2], params[:opts], params[:x], params[:y], params[:w], params[:h])
+      end
+    end
+  end
+
+  class FXDockBar
+    alias old_initialize initialize
+    def initialize(*args)
+      default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 3, :pr => 3, :pt => 2, :pb => 2, :hs => DEFAULT_SPACING, :vs => DEFAULT_SPACING }     
+      case args.length
+      when 1
+        params = default_params
+        old_initialize(args[0], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+      when 2
+        if args[1].is_a? Hash
+          params = args[1]
+          params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+          params = default_params.merge(params)
+          old_initialize(args[0], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+        else
+          params = default_params
+          old_initialize(args[0], args[1], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+        end
+      when 3
+        params = args[2]
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], args[1], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+      end
+    end
+  end
+  
+  class FXFont
+    alias old_initialize initialize
+    def initialize(*args)
+      case args.length
+      when 2
+        old_initialize(*args)
+      when 3,4
+        default_params = { :weight => FXFont::Normal, :slant => Font::Straight, :encoding => FONTENCODING_DEFAULT, :setWidth => FXFont::NonExpanded, :hints => 0 }     
+        params = (args.length == 4) ? args[3] : {}
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], args[1], args[2], params[:weight], params[:slant], params[:encoding], params[:setWidth], params[:hints])
+      end
+    end
+  end
+  
+  class FXGLCanvas
+    alias old_initialize initialize
+    def initialize(*args)
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }     
+      case args.length
+      when 2
+        params = default_params
+        old_initialize(args[0], args[1], params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+      when 3
+        if args[2].is_a? Hash
+          params = args[2]
+          params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+          params = default_params.merge(params)
+          old_initialize(args[0], args[1], params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+        else
+          params = default_params
+          old_initialize(args[0], args[1], args[2], params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+        end
+      when 4
+        params = args[3]
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], args[1], args[2], params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+      end
+    end
+  end
+
+  class FXGLViewer
+    alias old_initialize initialize
+    def initialize(*args)
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }     
+      case args.length
+      when 2
+        params = default_params
+        old_initialize(args[0], args[1], params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+      when 3
+        if args[2].is_a? Hash
+          params = args[2]
+          params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+          params = default_params.merge(params)
+          old_initialize(args[0], args[1], params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+        else
+          params = default_params
+          old_initialize(args[0], args[1], args[2], params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+        end
+      when 4
+        params = args[3]
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], args[1], args[2], params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+      end
+    end
+  end
+  
+  class FXMenuBar
+    alias old_initialize initialize
+    def initialize(*args)
+      if args.length == 2
+        old_initialize(*args)
+      else
+        default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+        params = args[2]
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        if (args[1].nil?) || (args[1].is_a? FXComposite)
+          old_initialize(args[0], args[1], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+        else 
+          old_initialize(args[0], args[1], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+        end
+      end
+    end
+  end
+
+  class FXSplitter
+    alias old_initialize initialize
+    def initialize(*args)
+      default_params = { :opts => SPLITTER_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0 }     
+      case args.length
+      when 1,2
+        params = (args.length == 2) ? args[1] : {}
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], params[:opts], params[:x], params[:y], params[:w], params[:h])
+      when 3,4
+        params = (args.length == 4) ? args[3] : {}
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], args[1], args[2], params[:opts], params[:x], params[:y], params[:w], params[:h])
+      end
+    end
+  end
+
+  class FXToolBar
+    alias old_initialize initialize
+    def initialize(*args)
+      default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 3, :pr => 3, :pt => 2, :pb => 2, :hs => DEFAULT_SPACING, :vs => DEFAULT_SPACING }     
+      case args.length
+      when 1
+        params = default_params
+        old_initialize(args[0], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+      when 2
+        if args[1].is_a? Hash
+          params = args[1]
+          params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+          params = default_params.merge(params)
+          old_initialize(args[0], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+        else
+          params = default_params
+          old_initialize(args[0], args[1], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+        end
+      when 3
+        params = args[2]
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], args[1], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+      end
+    end
+  end
+  
+  class FXWindow
+    alias old_initialize initialize
+    def initialize(*args)
+      if (args.length == 2) && (args[1].is_a? Hash)
+        default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+        params = args[1]
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(args[0], params[:opts], params[:x], params[:y], params[:w], params[:h])
+      else
+        old_initialize(*args)
+      end
+    end
+  end
+
+  class FX7Segment
+    alias old_initialize initialize
+    def initialize(p, text, params={})
+      default_params = { :opts => SEVENSEGMENT_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXAccelTable
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXEvent
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXApp
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = { :appName => "Application", :vendorName => "FoxDefault" }
+      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])
+    end
+  end
+
+  class FXArrowButton
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      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.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])
+    end
+  end
+
+  class FXBitmap
+    alias old_initialize initialize
+    def initialize(app, params={})
+      default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
+      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])
+    end
+  end
+
+  class FXBitmapFrame
+    alias old_initialize initialize
+    def initialize(p, bmp, params={})
+      default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 0, :pr => 0, :pt => 0, :pb => 0 }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXBitmapView
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :bmp => nil, :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXBMPIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => FXRGB(192,192,192), :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXBMPImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXButton
+    alias old_initialize initialize
+    def initialize(parent, text, params={})
+      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.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])
+    end
+  end
+
+  class FXCanvas
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      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])
+    end
+  end
+
+  class FXCheckButton
+    alias old_initialize initialize
+    def initialize(parent, text, params={})
+      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.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])
+    end
+  end
+
+  class FXChoiceBox
+    alias old_initialize initialize
+    def initialize(owner, caption, text, icon, choices, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXColorBar
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      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.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])
+    end
+  end
+
+  class FXColorDialog
+    alias old_initialize initialize
+    def initialize(owner, title, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      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])
+    end
+  end
+
+  class FXColorItem
+    alias old_initialize initialize
+    def initialize(text, clr, params={})
+      default_params = { :data => nil }
+      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])
+    end
+  end
+
+  class FXColorList
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => LIST_BROWSESELECT, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXColorRing
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXColorSelector
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      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])
+    end
+  end
+
+  class FXColorWell
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      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.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])
+    end
+  end
+
+  class FXColorWheel
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXComboBox
+    alias old_initialize initialize
+    def initialize(p, cols, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => COMBOBOX_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXComposite
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      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])
+    end
+  end
+
+  class FXCURCursor
+    alias old_initialize initialize
+    def initialize(app, pixels, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app, pixels)
+    end
+  end
+
+  class FXDataTarget
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = { :value => nil, :tgt => nil, :sel => 0 }
+      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[:tgt], params[:sel])
+    end
+  end
+
+  class FXSegment
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXArc
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXDC
+    alias old_initialize initialize
+    def initialize(app, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app)
+    end
+  end
+
+  class FXPSBounds
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXPrinter
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXDCPrint
+    alias old_initialize initialize
+    def initialize(app, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app)
+    end
+  end
+
+  class FXDCWindow
+    alias old_initialize initialize
+    def initialize(drawable, params={})
+      default_params = { :event => nil }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(drawable, params[:event])
+    end
+  end
+
+  class FXDebugTarget
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXDelegator
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = { :delegate => nil }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:delegate])
+    end
+  end
+
+  class FXDial
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => DIAL_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXDialogBox
+    alias old_initialize initialize
+    def initialize(owner, title, params={})
+      default_params = { :opts => DECOR_TITLE|DECOR_BORDER, :x => 0, :y => 0, :w => 0, :h => 0, :padLeft => 10, :padRight => 10, :padTop => 10, :padBottom => 10, :hSpacing => 4, :vSpacing => 4 }
+      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[:w], params[:h], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing])
+    end
+  end
+
+  class FXDict
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXDirBox
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXDirDialog
+    alias old_initialize initialize
+    def initialize(owner, name, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 500, :h => 300 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXDirItem
+    alias old_initialize initialize
+    def initialize(text, params={})
+      default_params = { :oi => nil, :ci => nil, :data => nil }
+      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])
+    end
+  end
+
+  class FXDirList
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXDirSelector
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXDockHandler
+    alias old_initialize initialize
+    def initialize(p, tgt, sel, opts, x, y, w, h, pl, pr, pt, pb, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, tgt, sel, opts, x, y, w, h, pl, pr, pt, pb)
+    end
+  end
+
+  class FXDockSite
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 0, :pr => 0, :pt => 0, :pb => 0, :hs => 0, :vs => 0 }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+    end
+  end
+
+  class FXDockTitle
+    alias old_initialize initialize
+    def initialize(p, text, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_NORMAL|JUSTIFY_CENTER_X|JUSTIFY_CENTER_Y, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 0, :pr => 0, :pt => 0, :pb => 0 }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXDocument
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXDragCorner
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p)
+    end
+  end
+
+  class FXDrawable
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXDriveBox
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXFileDialog
+    alias old_initialize initialize
+    def initialize(owner, name, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 500, :h => 300 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXFileAssoc
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXFileDict
+    alias old_initialize initialize
+    def initialize(app, params={})
+      default_params = { :db => nil }
+      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])
+    end
+  end
+
+  class FXFileItem
+    alias old_initialize initialize
+    def initialize(text, params={})
+      default_params = { :bi => nil, :mi => nil, :ptr => nil }
+      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])
+    end
+  end
+
+  class FXFileList
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXFileSelector
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXFileStream
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = { :cont => nil }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:cont])
+    end
+  end
+
+  class FXFoldingItem
+    alias old_initialize initialize
+    def initialize(text, params={})
+      default_params = { :openIcon => nil, :closedIcon => nil, :data => nil }
+      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])
+    end
+  end
+
+  class FXFoldingList
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => TREELIST_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXFontDesc
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXFontDialog
+    alias old_initialize initialize
+    def initialize(owner, name, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 600, :h => 380 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXFontSelector
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXFrame
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      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.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])
+    end
+  end
+
+  class FXGIFCursor
+    alias old_initialize initialize
+    def initialize(a, pix, params={})
+      default_params = { :hx => -1, :hy => -1 }
+      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])
+    end
+  end
+
+  class FXGIFIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXGIFImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXGLContext
+    alias old_initialize initialize
+    def initialize(app, visual, params={})
+      default_params = { :other => nil }
+      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])
+    end
+  end
+
+  class FXGLObject
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXGLShape
+    alias old_initialize initialize
+    def initialize(x, y, z, opts, params={})
+      default_params = { :front => nil, :back => nil }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(x, y, z, opts, params[:front], params[:back])
+    end
+  end
+
+  class FXViewport
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXLight
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXMaterial
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXGLVisual
+    alias old_initialize initialize
+    def initialize(app, flags, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app, flags)
+    end
+  end
+
+  class FXGradient
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXGradientBar
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXGroupBox
+    alias old_initialize initialize
+    def initialize(parent, text, params={})
+      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.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])
+    end
+  end
+
+  class FXHeaderItem
+    alias old_initialize initialize
+    def initialize(text, params={})
+      default_params = { :ic => nil, :s => 0, :ptr => nil }
+      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])
+    end
+  end
+
+  class FXHeader
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => HEADER_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXHorizontalFrame
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_SPACING, :pr => DEFAULT_SPACING, :pt => DEFAULT_SPACING, :pb => DEFAULT_SPACING, :hs => DEFAULT_SPACING, :vs => DEFAULT_SPACING }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+    end
+  end
+
+  class FXICOIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXICOImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXIcon
+    alias old_initialize initialize
+    def initialize(app, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXIconDict
+    alias old_initialize initialize
+    def initialize(app, params={})
+      default_params = { :path => defaultIconPath }
+      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])
+    end
+  end
+
+  class FXIconItem
+    alias old_initialize initialize
+    def initialize(text, params={})
+      default_params = { :bigIcon => nil, :miniIcon => nil, :data => nil }
+      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])
+    end
+  end
+
+  class FXIconList
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => ICONLIST_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXIconSource
+    alias old_initialize initialize
+    def initialize(app, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app)
+    end
+  end
+
+  class FXId
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pixels => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXImageFrame
+    alias old_initialize initialize
+    def initialize(p, img, params={})
+      default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 0, :pr => 0, :pt => 0, :pb => 0 }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXImageView
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :img => nil, :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXInputDialog
+    alias old_initialize initialize
+    def initialize(owner, caption, label, params={})
+      default_params = { :icon => nil, :opts => INPUTDIALOG_STRING, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXJPGIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXJPGImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXKnob
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => KNOB_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXLabel
+    alias old_initialize initialize
+    def initialize(parent, text, params={})
+      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.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])
+    end
+  end
+
+  class FXListItem
+    alias old_initialize initialize
+    def initialize(text, params={})
+      default_params = { :icon => nil, :data => nil }
+      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])
+    end
+  end
+
+  class FXList
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => LIST_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXListBox
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXMainWindow
+    alias old_initialize initialize
+    def initialize(app, title, params={})
+      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.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])
+    end
+  end
+
+  class FXMatrix
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      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.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])
+    end
+  end
+
+  class FXMDIDeleteButton
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXMDIRestoreButton
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXMDIMaximizeButton
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXMDIMinimizeButton
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXMDIWindowButton
+    alias old_initialize initialize
+    def initialize(p, pup, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXMDIMenu
+    alias old_initialize initialize
+    def initialize(owner, params={})
+      default_params = { :tgt => nil }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, params[:tgt])
+    end
+  end
+
+  class FXMDIChild
+    alias old_initialize initialize
+    def initialize(p, name, params={})
+      default_params = { :ic => nil, :pup => nil, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXMDIClient
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXMemoryBuffer
+    alias old_initialize initialize
+    def initialize(data, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(data)
+    end
+  end
+
+  class FXMemoryStream
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = { :cont => nil }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:cont])
+    end
+  end
+
+  class FXMenuButton
+    alias old_initialize initialize
+    def initialize(parent, text, params={})
+      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.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])
+    end
+  end
+
+  class FXMenuCaption
+    alias old_initialize initialize
+    def initialize(parent, text, params={})
+      default_params = { :icon => nil, :opts => 0 }
+      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])
+    end
+  end
+
+  class FXMenuCascade
+    alias old_initialize initialize
+    def initialize(parent, text, params={})
+      default_params = { :icon => nil, :popupMenu => nil, :opts => 0 }
+      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])
+    end
+  end
+
+  class FXMenuCheck
+    alias old_initialize initialize
+    def initialize(p, text, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0 }
+      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[:tgt], params[:sel], params[:opts])
+    end
+  end
+
+  class FXMenuCommand
+    alias old_initialize initialize
+    def initialize(p, text, params={})
+      default_params = { :ic => nil, :tgt => nil, :sel => 0, :opts => 0 }
+      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[:tgt], params[:sel], params[:opts])
+    end
+  end
+
+  class FXMenuPane
+    alias old_initialize initialize
+    def initialize(owner, params={})
+      default_params = { :opts => 0 }
+      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])
+    end
+  end
+
+  class FXMenuRadio
+    alias old_initialize initialize
+    def initialize(p, text, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0 }
+      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[:tgt], params[:sel], params[:opts])
+    end
+  end
+
+  class FXMenuSeparator
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      default_params = { :opts => 0 }
+      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])
+    end
+  end
+
+  class FXMenuTitle
+    alias old_initialize initialize
+    def initialize(parent, text, params={})
+      default_params = { :icon => nil, :popupMenu => nil, :opts => 0 }
+      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])
+    end
+  end
+
+  class FXMessageBox
+    alias old_initialize initialize
+    def initialize(owner, caption, text, params={})
+      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0 }
+      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])
+    end
+  end
+
+  class FXObject
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXOption
+    alias old_initialize initialize
+    def initialize(p, text, params={})
+      default_params = { :ic => nil, :tgt => nil, :sel => 0, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXOptionMenu
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :pup => nil, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXPCXIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXPCXImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXPicker
+    alias old_initialize initialize
+    def initialize(p, text, params={})
+      default_params = { :ic => nil, :tgt => nil, :sel => 0, :opts => BUTTON_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXPNGIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXPNGImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXPopup
+    alias old_initialize initialize
+    def initialize(owner, params={})
+      default_params = { :opts => POPUP_VERTICAL|FRAME_RAISED|FRAME_THICK, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXPPMIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXPPMImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXPrintDialog
+    alias old_initialize initialize
+    def initialize(owner, name, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXProgressBar
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => PROGRESSBAR_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXProgressDialog
+    alias old_initialize initialize
+    def initialize(owner, caption, label, params={})
+      default_params = { :opts => PROGRESSDIALOG_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXRadioButton
+    alias old_initialize initialize
+    def initialize(parent, text, params={})
+      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.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])
+    end
+  end
+
+  class FXRealSlider
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => REALSLIDER_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 0, :pr => 0, :pt => 0, :pb => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXRealSpinner
+    alias old_initialize initialize
+    def initialize(p, cols, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => REALSPIN_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXRegistry
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = { :appKey => "", :vendorKey => "" }
+      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])
+    end
+  end
+
+  class FXReplaceDialog
+    alias old_initialize initialize
+    def initialize(owner, caption, params={})
+      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXRGBIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXRGBImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXRootWindow
+    alias old_initialize initialize
+    def initialize(a, vis, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, vis)
+    end
+  end
+
+  class FXRuler
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => RULER_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXRulerView
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class NotifyHeader
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class SCNotification
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class TextRange
+    alias old_initialize initialize
+    def initialize(start, last, size, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(start, last, size)
+    end
+  end
+
+  class FXScintilla
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXScrollArea
+    alias old_initialize initialize
+    def initialize(parent, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      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])
+    end
+  end
+
+  class FXScrollBar
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => SCROLLBAR_VERTICAL, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXScrollCorner
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p)
+    end
+  end
+
+  class FXScrollPane
+    alias old_initialize initialize
+    def initialize(owner, nvis, params={})
+      default_params = { :opts => 0 }
+      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])
+    end
+  end
+
+  class FXScrollWindow
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXSearchDialog
+    alias old_initialize initialize
+    def initialize(owner, caption, params={})
+      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXSeparator
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 0, :pr => 0, :pt => 0, :pb => 0 }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXHorizontalSeparator
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 1, :pr => 1, :pt => 0, :pb => 0 }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXVerticalSeparator
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_Y, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 0, :pr => 0, :pt => 1, :pb => 1 }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXSettings
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXShell
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXShutterItem
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :text => "", :icon => nil, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_SPACING, :pr => DEFAULT_SPACING, :pt => DEFAULT_SPACING, :pb => DEFAULT_SPACING, :hs => DEFAULT_SPACING, :vs => DEFAULT_SPACING }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+    end
+  end
+
+  class FXShutter
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_SPACING, :pr => DEFAULT_SPACING, :pt => DEFAULT_SPACING, :pb => DEFAULT_SPACING, :hs => DEFAULT_SPACING, :vs => DEFAULT_SPACING }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+    end
+  end
+
+  class FXSlider
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => SLIDER_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 0, :pr => 0, :pt => 0, :pb => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXSpinner
+    alias old_initialize initialize
+    def initialize(p, cols, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => SPIN_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXSplashWindow
+    alias old_initialize initialize
+    def initialize(owner, icon, params={})
+      default_params = { :opts => SPLASH_SIMPLE, :ms => 5000 }
+      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])
+    end
+  end
+
+  class FXSpring
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => 0, :relw => 0, :relh => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_SPACING, :pr => DEFAULT_SPACING, :pt => DEFAULT_SPACING, :pb => DEFAULT_SPACING, :hs => DEFAULT_SPACING, :vs => DEFAULT_SPACING }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+    end
+  end
+
+  class FXStatusBar
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 3, :pr => 3, :pt => 2, :pb => 2, :hs => 4, :vs => 0 }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+    end
+  end
+
+  class FXStatusLine
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel])
+    end
+  end
+
+  class FXStream
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = { :cont => nil }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:cont])
+    end
+  end
+
+  class FXStringDict
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXSwitcher
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_SPACING, :pr => DEFAULT_SPACING, :pt => DEFAULT_SPACING, :pb => DEFAULT_SPACING }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXTabBar
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_SPACING, :pr => DEFAULT_SPACING, :pt => DEFAULT_SPACING, :pb => DEFAULT_SPACING }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXTabBook
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_SPACING, :pr => DEFAULT_SPACING, :pt => DEFAULT_SPACING, :pb => DEFAULT_SPACING }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXTabItem
+    alias old_initialize initialize
+    def initialize(p, text, params={})
+      default_params = { :ic => nil, :opts => TAB_TOP_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXTablePos
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXTableRange
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXTableItem
+    alias old_initialize initialize
+    def initialize(text, params={})
+      default_params = { :icon => nil, :data => nil }
+      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])
+    end
+  end
+
+  class FXTable
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_MARGIN, :pr => DEFAULT_MARGIN, :pt => DEFAULT_MARGIN, :pb => DEFAULT_MARGIN }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXHiliteStyle
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXTextChange
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXText
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 3, :pr => 3, :pt => 2, :pb => 2 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXTextField
+    alias old_initialize initialize
+    def initialize(p, ncols, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => TEXTFIELD_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXTGAIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXTGAImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXTIFIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXTIFImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXToggleButton
+    alias old_initialize initialize
+    def initialize(p, text1, text2, params={})
+      default_params = { :icon1 => nil, :icon2 => nil, :tgt => nil, :sel => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXToolBarGrip
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => TOOLBARGRIP_SINGLE, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXToolBarShell
+    alias old_initialize initialize
+    def initialize(owner, params={})
+      default_params = { :opts => FRAME_RAISED|FRAME_THICK, :x => 0, :y => 0, :w => 0, :h => 0, :hs => 4, :vs => 4 }
+      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[:w], params[:h], params[:hs], params[:vs])
+    end
+  end
+
+  class FXToolBarTab
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXToolTip
+    alias old_initialize initialize
+    def initialize(app, params={})
+      default_params = { :opts => TOOLTIP_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXTopWindow
+    alias old_initialize initialize
+    def initialize(params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize()
+    end
+  end
+
+  class FXTranslator
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a)
+    end
+  end
+
+  class FXTreeItem
+    alias old_initialize initialize
+    def initialize(text, params={})
+      default_params = { :openIcon => nil, :closedIcon => nil, :data => nil }
+      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])
+    end
+  end
+
+  class FXTreeList
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => TREELIST_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h])
+    end
+  end
+
+  class FXTreeListBox
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :tgt => nil, :sel => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXTriStateButton
+    alias old_initialize initialize
+    def initialize(p, text1, text2, text3, params={})
+      default_params = { :icon1 => nil, :icon2 => nil, :icon3 => nil, :tgt => nil, :sel => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_PAD, :pr => DEFAULT_PAD, :pt => DEFAULT_PAD, :pb => DEFAULT_PAD }
+      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[:tgt], params[:sel], params[:opts], params[:x], params[:y], params[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb])
+    end
+  end
+
+  class FXVec2d
+    alias old_initialize initialize
+    def initialize(xx, yy, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(xx, yy)
+    end
+  end
+
+  class FXVec2f
+    alias old_initialize initialize
+    def initialize(xx, yy, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(xx, yy)
+    end
+  end
+
+  class FXVec3d
+    alias old_initialize initialize
+    def initialize(xx, yy, zz, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(xx, yy, zz)
+    end
+  end
+
+  class FXVec3f
+    alias old_initialize initialize
+    def initialize(xx, yy, zz, params={})
+      default_params = {  }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(xx, yy, zz)
+    end
+  end
+
+  class FXVec4d
+    alias old_initialize initialize
+    def initialize(xx, yy, zz, params={})
+      default_params = { :ww => 1.0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(xx, yy, zz, params[:ww])
+    end
+  end
+
+  class FXVec4f
+    alias old_initialize initialize
+    def initialize(xx, yy, zz, params={})
+      default_params = { :ww => 1.0 }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(xx, yy, zz, params[:ww])
+    end
+  end
+
+  class FXVerticalFrame
+    alias old_initialize initialize
+    def initialize(p, params={})
+      default_params = { :opts => 0, :x => 0, :y => 0, :w => 0, :h => 0, :pl => DEFAULT_SPACING, :pr => DEFAULT_SPACING, :pt => DEFAULT_SPACING, :pb => DEFAULT_SPACING, :hs => DEFAULT_SPACING, :vs => DEFAULT_SPACING }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+    end
+  end
+
+  class FXVisual
+    alias old_initialize initialize
+    def initialize(a, flgs, params={})
+      default_params = { :d => 32 }
+      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])
+    end
+  end
+
+  class FXWizard
+    alias old_initialize initialize
+    def initialize(owner, name, image, params={})
+      default_params = { :opts => DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE, :x => 0, :y => 0, :w => 0, :h => 0, :pl => 10, :pr => 10, :pt => 10, :pb => 10, :hs => 10, :vs => 10 }
+      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[:w], params[:h], params[:pl], params[:pr], params[:pt], params[:pb], params[:hs], params[:vs])
+    end
+  end
+
+  class FXXBMIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pixels => nil, :mask => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXXBMImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pixels => nil, :mask => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXXPMIcon
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+  class FXXPMImage
+    alias old_initialize initialize
+    def initialize(a, params={})
+      default_params = { :pix => nil, :opts => 0, :w => 1, :h => 1 }
+      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[:w], params[:h])
+    end
+  end
+
+end