fxruby 1.6.29-x86-mingw32 → 1.6.30-x86-mingw32

data/ext/fox16_c/include/FXRbText.h

@@ -74,73 +74,73 @@ inline void klass ## _setStyledText(klass* self,const FXString& text,FXint style
 
 #define IMPLEMENT_FXTEXT_STUBS(cls) \
   void cls::setCursorPos(FXint pos,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setCursorPos"),pos,notify); \
+    FXRbCallVoidMethod(this,"setCursorPos",pos,notify); \
     } \
   FXbool cls::extendSelection(FXint pos,FXTextSelectionMode mode,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("extendSelection"),pos,mode,notify); \
+    return FXRbCallBoolMethod(this,"extendSelection",pos,mode,notify); \
     } \
   FXbool cls::killSelection(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("killSelection"),notify); \
+    return FXRbCallBoolMethod(this,"killSelection",notify); \
     } \
   void cls::replaceText(FXint pos,FXint m,const FXchar *text,FXint n,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("replaceText"),pos,m,FXString(text,n),notify); \
+    FXRbCallVoidMethod(this,"replaceText",pos,m,FXString(text,n),notify); \
     } \
   void cls::replaceText(FXint pos,FXint m,const FXString& text,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("replaceText"),pos,m,text,notify); \
+    FXRbCallVoidMethod(this,"replaceText",pos,m,text,notify); \
     } \
   void cls::replaceStyledText(FXint pos,FXint m,const FXchar *text,FXint n,FXint style,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("replaceStyledText"),pos,m,FXString(text,n),style,notify); \
+    FXRbCallVoidMethod(this,"replaceStyledText",pos,m,FXString(text,n),style,notify); \
     } \
   void cls::replaceStyledText(FXint pos,FXint m,const FXString& text,FXint style,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("replaceStyledText"),pos,m,text,style,notify); \
+    FXRbCallVoidMethod(this,"replaceStyledText",pos,m,text,style,notify); \
     } \
   void cls::appendText(const FXchar *text,FXint n,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("appendText"),FXString(text,n),notify); \
+    FXRbCallVoidMethod(this,"appendText",FXString(text,n),notify); \
     } \
   void cls::appendText(const FXString& text,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("appendText"),text,notify); \
+    FXRbCallVoidMethod(this,"appendText",text,notify); \
     } \
   void cls::appendStyledText(const FXchar *text,FXint n,FXint style,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("appendStyledText"),FXString(text,n),style,notify); \
+    FXRbCallVoidMethod(this,"appendStyledText",FXString(text,n),style,notify); \
     } \
   void cls::appendStyledText(const FXString& text,FXint style,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("appendStyledText"),text,style,notify); \
+    FXRbCallVoidMethod(this,"appendStyledText",text,style,notify); \
     } \
   void cls::insertText(FXint pos,const FXchar *text,FXint n,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("insertText"),pos,FXString(text,n),notify); \
+    FXRbCallVoidMethod(this,"insertText",pos,FXString(text,n),notify); \
     } \
   void cls::insertText(FXint pos,const FXString& text,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("insertText"),pos,text,notify); \
+    FXRbCallVoidMethod(this,"insertText",pos,text,notify); \
     } \
   void cls::insertStyledText(FXint pos,const FXchar *text,FXint n,FXint style,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("insertStyledText"),pos,FXString(text,n),style,notify); \
+    FXRbCallVoidMethod(this,"insertStyledText",pos,FXString(text,n),style,notify); \
     } \
   void cls::insertStyledText(FXint pos,const FXString& text,FXint style,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("insertStyledText"),pos,text,style,notify); \
+    FXRbCallVoidMethod(this,"insertStyledText",pos,text,style,notify); \
     } \
   void cls::removeText(FXint pos,FXint n,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("removeText"),pos,n,notify); \
+    FXRbCallVoidMethod(this,"removeText",pos,n,notify); \
     } \
   void cls::changeStyle(FXint pos,FXint n,FXint style){ \
-    FXRbCallVoidMethod(this,rb_intern("changeStyle"),pos,n,style); \
+    FXRbCallVoidMethod(this,"changeStyle",pos,n,style); \
     } \
   void cls::changeStyle(FXint pos,const FXchar* style,FXint n){ \
-    FXRbCallVoidMethod(this,rb_intern("changeStyle"),pos,FXString(style,n)); \
+    FXRbCallVoidMethod(this,"changeStyle",pos,FXString(style,n)); \
     } \
   void cls::changeStyle(FXint pos,const FXString& style){ \
-    FXRbCallVoidMethod(this,rb_intern("changeStyle"),pos,style); \
+    FXRbCallVoidMethod(this,"changeStyle",pos,style); \
     } \
   void cls::setText(const FXchar* text,FXint n,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setText"),FXString(text,n),notify); \
+    FXRbCallVoidMethod(this,"setText",FXString(text,n),notify); \
     } \
   void cls::setText(const FXString& text,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setText"),text,notify); \
+    FXRbCallVoidMethod(this,"setText",text,notify); \
     } \
   void cls::setStyledText(const FXchar* text,FXint n,FXint style,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setStyledText"),FXString(text,n),style,notify); \
+    FXRbCallVoidMethod(this,"setStyledText",FXString(text,n),style,notify); \
     } \
   void cls::setStyledText(const FXString& text,FXint style,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setStyledText"),text,style,notify); \
+    FXRbCallVoidMethod(this,"setStyledText",text,style,notify); \
     }
 
 

data/ext/fox16_c/include/FXRbTopWindow.h

@@ -47,19 +47,19 @@ inline FXbool klass ## _close(klass* self,FXbool notify){ \
 
 #define IMPLEMENT_FXTOPWINDOW_STUBS(cls) \
   void cls::show(FXuint placement){ \
-    FXRbCallVoidMethod(this,rb_intern("show"),placement); \
+    FXRbCallVoidMethod(this,"show",placement); \
     } \
   FXbool cls::maximize(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("maximize"),notify); \
+    return FXRbCallBoolMethod(this,"maximize",notify); \
     } \
   FXbool cls::minimize(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("minimize"),notify); \
+    return FXRbCallBoolMethod(this,"minimize",notify); \
     } \
   FXbool cls::restore(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("restore"),notify); \
+    return FXRbCallBoolMethod(this,"restore",notify); \
     } \
   FXbool cls::close(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("close"),notify); \
+    return FXRbCallBoolMethod(this,"close",notify); \
     }
 
 

data/ext/fox16_c/include/FXRbTranslator.h

@@ -35,7 +35,7 @@ inline const FXchar* klass ## _tr(const klass* self,const FXchar* context,const
 
 #define IMPLEMENT_FXTRANSLATOR_STUBS(cls) \
   const FXchar* cls::tr(const FXchar* context,const FXchar* message,const FXchar* hint) const { \
-    return FXRbCallCStringMethod(this,rb_intern("tr"),context,message,hint); \
+    return FXRbCallCStringMethod(this,"tr",context,message,hint); \
     }
 
 class FXRbTranslator : public FXTranslator {

data/ext/fox16_c/include/FXRbTreeList.h

@@ -74,51 +74,51 @@ inline void klass ## _destroy(klass* self){ \
 
 #define IMPLEMENT_FXTREEITEM_STUBS(klass,superklass) \
   void klass::setText(const FXString& txt){ \
-    FXRbCallVoidMethod(this,rb_intern("setText"),txt); \
+    FXRbCallVoidMethod(this,"setText",txt); \
     } \
   void klass::setOpenIcon(FXIcon* icn,FXbool owned){ \
-    FXRbCallVoidMethod(this,rb_intern("setOpenIcon"),icn,owned); \
+    FXRbCallVoidMethod(this,"setOpenIcon",icn,owned); \
     } \
   void klass::setClosedIcon(FXIcon* icn,FXbool owned){ \
-    FXRbCallVoidMethod(this,rb_intern("setClosedIcon"),icn,owned); \
+    FXRbCallVoidMethod(this,"setClosedIcon",icn,owned); \
     } \
   void klass::setFocus(FXbool focus){ \
     if(NIL_P(FXRbGetRubyObj(this,false))){ \
       superklass::setFocus(focus); \
       } \
     else{ \
-      FXRbCallVoidMethod(this,rb_intern("setFocus"),focus); \
+      FXRbCallVoidMethod(this,"setFocus",focus); \
       } \
     } \
   void klass::setSelected(FXbool selected){ \
-    FXRbCallVoidMethod(this,rb_intern("setSelected"),selected); \
+    FXRbCallVoidMethod(this,"setSelected",selected); \
     } \
   void klass::setOpened(FXbool opened){ \
-    FXRbCallVoidMethod(this,rb_intern("setOpened"),opened); \
+    FXRbCallVoidMethod(this,"setOpened",opened); \
     } \
   void klass::setExpanded(FXbool expanded){ \
-    FXRbCallVoidMethod(this,rb_intern("setExpanded"),expanded); \
+    FXRbCallVoidMethod(this,"setExpanded",expanded); \
     } \
   void klass::setEnabled(FXbool enabled){ \
-    FXRbCallVoidMethod(this,rb_intern("setEnabled"),enabled); \
+    FXRbCallVoidMethod(this,"setEnabled",enabled); \
     } \
   void klass::setDraggable(FXbool draggable){ \
-    FXRbCallVoidMethod(this,rb_intern("setDraggable"),draggable); \
+    FXRbCallVoidMethod(this,"setDraggable",draggable); \
     } \
   FXint klass::getWidth(const FXTreeList* list) const { \
-    return FXRbCallIntMethod(this,rb_intern("getWidth"),list); \
+    return FXRbCallIntMethod(this,"getWidth",list); \
     } \
   FXint klass::getHeight(const FXTreeList* list) const { \
-    return FXRbCallIntMethod(this,rb_intern("getHeight"),list); \
+    return FXRbCallIntMethod(this,"getHeight",list); \
     } \
   void klass::create(){ \
-    FXRbCallVoidMethod(this,rb_intern("create")); \
+    FXRbCallVoidMethod(this,"create"); \
     } \
   void klass::detach(){ \
-    FXRbCallVoidMethod(this,rb_intern("detach")); \
+    FXRbCallVoidMethod(this,"detach"); \
     } \
   void klass::destroy(){ \
-    FXRbCallVoidMethod(this,rb_intern("destroy")); \
+    FXRbCallVoidMethod(this,"destroy"); \
     }
 
 
@@ -195,46 +195,46 @@ inline FXbool klass ## _disableItem(klass* self,FXTreeItem* item){ \
 
 #define IMPLEMENT_FXTREELIST_STUBS(cls) \
   FXbool cls::selectItem(FXTreeItem* item,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("selectItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"selectItem",item,notify); \
     } \
   FXbool cls::deselectItem(FXTreeItem* item,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("deselectItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"deselectItem",item,notify); \
     } \
   FXbool cls::toggleItem(FXTreeItem* item,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("toggleItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"toggleItem",item,notify); \
     } \
   FXbool cls::extendSelection(FXTreeItem* item,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("extendSelection"),item,notify); \
+    return FXRbCallBoolMethod(this,"extendSelection",item,notify); \
     } \
   FXbool cls::killSelection(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("killSelection"),notify); \
+    return FXRbCallBoolMethod(this,"killSelection",notify); \
     } \
   FXbool cls::openItem(FXTreeItem* item,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("openItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"openItem",item,notify); \
     } \
   FXbool cls::closeItem(FXTreeItem* item,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("closeItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"closeItem",item,notify); \
     } \
   FXbool cls::collapseTree(FXTreeItem* tree,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("collapseTree"),tree,notify); \
+    return FXRbCallBoolMethod(this,"collapseTree",tree,notify); \
     } \
   FXbool cls::expandTree(FXTreeItem* tree,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("expandTree"),tree,notify); \
+    return FXRbCallBoolMethod(this,"expandTree",tree,notify); \
     } \
   void cls::setCurrentItem(FXTreeItem* item,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setCurrentItem"),item,notify); \
+    FXRbCallVoidMethod(this,"setCurrentItem",item,notify); \
     } \
   FXTreeItem* cls::getItemAt(FXint x,FXint y) const { \
-    return FXRbCallTreeItemMethod(this,rb_intern("getItemAt"),x,y); \
+    return FXRbCallTreeItemMethod(this,"getItemAt",x,y); \
     } \
   void cls::makeItemVisible(FXTreeItem* item) { \
-    FXRbCallVoidMethod(this,rb_intern("makeItemVisible"),item); \
+    FXRbCallVoidMethod(this,"makeItemVisible",item); \
     } \
   FXbool cls::enableItem(FXTreeItem* item){ \
-    return FXRbCallBoolMethod(this,rb_intern("enableItem"),item); \
+    return FXRbCallBoolMethod(this,"enableItem",item); \
     } \
   FXbool cls::disableItem(FXTreeItem* item){ \
-    return FXRbCallBoolMethod(this,rb_intern("disableItem"),item); \
+    return FXRbCallBoolMethod(this,"disableItem",item); \
     }
 
 

data/ext/fox16_c/include/FXRbTreeListBox.h

@@ -34,7 +34,7 @@ inline void klass ## _setCurrentItem(klass* self,FXTreeItem* item,FXbool notify)
 
 #define IMPLEMENT_FXTREELISTBOX_STUBS(cls) \
   void cls::setCurrentItem(FXTreeItem* item,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setCurrentItem"),item,notify); \
+    FXRbCallVoidMethod(this,"setCurrentItem",item,notify); \
     }
 
 class FXRbTreeListBox : public FXTreeListBox {

data/ext/fox16_c/include/FXRbWindow.h

@@ -125,97 +125,97 @@ inline void klass ## _dropDisable(klass* self){ \
 
 #define IMPLEMENT_FXWINDOW_STUBS(cls) \
   void cls::layout(){ \
-    FXRbCallVoidMethod(this,rb_intern("layout")); \
+    FXRbCallVoidMethod(this,"layout"); \
     } \
   FXint cls::getDefaultWidth(){ \
-    return FXRbCallIntMethod(this,rb_intern("getDefaultWidth")); \
+    return FXRbCallIntMethod(this,"getDefaultWidth"); \
     } \
   FXint cls::getDefaultHeight(){ \
-    return FXRbCallIntMethod(this,rb_intern("getDefaultHeight")); \
+    return FXRbCallIntMethod(this,"getDefaultHeight"); \
     } \
   FXint cls::getWidthForHeight(FXint givenheight){ \
-    return FXRbCallIntMethod(this,rb_intern("getWidthForHeight"),givenheight); \
+    return FXRbCallIntMethod(this,"getWidthForHeight",givenheight); \
     } \
   FXint cls::getHeightForWidth(FXint givenwidth){ \
-    return FXRbCallIntMethod(this,rb_intern("getHeightForWidth"),givenwidth); \
+    return FXRbCallIntMethod(this,"getHeightForWidth",givenwidth); \
     } \
   bool cls::canFocus() const { \
-    return FXRbCallBoolMethod(this,rb_intern("canFocus")); \
+    return FXRbCallBoolMethod(this,"canFocus"); \
     } \
   void cls::setFocus(){ \
-    FXRbCallVoidMethod(this,rb_intern("setFocus")); \
+    FXRbCallVoidMethod(this,"setFocus"); \
     } \
   void cls::killFocus(){ \
-    FXRbCallVoidMethod(this,rb_intern("killFocus")); \
+    FXRbCallVoidMethod(this,"killFocus"); \
     } \
   void cls::changeFocus(FXWindow* child){ \
-    if(!FXRbIsInGC(this)) FXRbCallVoidMethod(this,rb_intern("changeFocus"),child); \
+    if(!FXRbIsInGC(this)) FXRbCallVoidMethod(this,"changeFocus",child); \
     } \
   void cls::setDefault(FXbool enable){ \
-    FXRbCallVoidMethod(this,rb_intern("setDefault"),enable); \
+    FXRbCallVoidMethod(this,"setDefault",enable); \
     } \
   void cls::enable(){ \
-    FXRbCallVoidMethod(this,rb_intern("enable")); \
+    FXRbCallVoidMethod(this,"enable"); \
     } \
   void cls::disable(){ \
-    FXRbCallVoidMethod(this,rb_intern("disable")); \
+    FXRbCallVoidMethod(this,"disable"); \
     } \
   void cls::raise(){ \
-    FXRbCallVoidMethod(this,rb_intern("raiseWindow")); \
+    FXRbCallVoidMethod(this,"raiseWindow"); \
     } \
   void cls::lower(){ \
-    FXRbCallVoidMethod(this,rb_intern("lower")); \
+    FXRbCallVoidMethod(this,"lower"); \
     } \
   void cls::move(FXint x,FXint y){ \
-    FXRbCallVoidMethod(this,rb_intern("move"),x,y); \
+    FXRbCallVoidMethod(this,"move",x,y); \
     } \
   void cls::position(FXint x,FXint y,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("position"),x,y,w,h); \
+    FXRbCallVoidMethod(this,"position",x,y,w,h); \
     } \
   void cls::recalc(){ \
-    if(!FXRbIsInGC(this)) FXRbCallVoidMethod(this,rb_intern("recalc")); \
+    if(!FXRbIsInGC(this)) FXRbCallVoidMethod(this,"recalc"); \
     } \
   void cls::reparent(FXWindow* father,FXWindow* other){ \
-    FXRbCallVoidMethod(this,rb_intern("reparent"),father,other); \
+    FXRbCallVoidMethod(this,"reparent",father,other); \
     } \
   void cls::show(){ \
-    FXRbCallVoidMethod(this,rb_intern("show")); \
+    FXRbCallVoidMethod(this,"show"); \
     } \
   void cls::hide(){ \
-    FXRbCallVoidMethod(this,rb_intern("hide")); \
+    FXRbCallVoidMethod(this,"hide"); \
     } \
   bool cls::isComposite() const { \
-    return FXRbCallBoolMethod(this,rb_intern("isComposite")); \
+    return FXRbCallBoolMethod(this,"isComposite"); \
     } \
   bool cls::contains(FXint parentx,FXint parenty) const{ \
-    return FXRbCallBoolMethod(this,rb_intern("contains"),parentx,parenty); \
+    return FXRbCallBoolMethod(this,"contains",parentx,parenty); \
     } \
   bool cls::doesSaveUnder() const { \
-    return FXRbCallBoolMethod(this,rb_intern("doesSaveUnder")); \
+    return FXRbCallBoolMethod(this,"doesSaveUnder"); \
     } \
   void cls::setBackColor(FXColor clr) { \
-    FXRbCallVoidMethod(this,rb_intern("setBackColor"),clr); \
+    FXRbCallVoidMethod(this,"setBackColor",clr); \
     } \
   const FXchar* cls::tr(const FXchar* message,const FXchar* hint) const { \
-    return FXRbCallCStringMethod(this,rb_intern("tr"),message,hint); \
+    return FXRbCallCStringMethod(this,"tr",message,hint); \
     } \
   void cls::setShape(const FXRegion& region) { \
-    FXRbCallVoidMethod(this,rb_intern("setShape"),region); \
+    FXRbCallVoidMethod(this,"setShape",region); \
     } \
   void cls::setShape(FXBitmap* bitmap) { \
-    FXRbCallVoidMethod(this,rb_intern("setShape"),bitmap); \
+    FXRbCallVoidMethod(this,"setShape",bitmap); \
     } \
   void cls::setShape(FXIcon* icon) { \
-    FXRbCallVoidMethod(this,rb_intern("setShape"),icon); \
+    FXRbCallVoidMethod(this,"setShape",icon); \
     } \
   void cls::clearShape() { \
-    FXRbCallVoidMethod(this,rb_intern("clearShape")); \
+    FXRbCallVoidMethod(this,"clearShape"); \
     } \
   void cls::dropEnable() { \
-    FXRbCallVoidMethod(this,rb_intern("dropEnable")); \
+    FXRbCallVoidMethod(this,"dropEnable"); \
     } \
   void cls::dropDisable() { \
-    FXRbCallVoidMethod(this,rb_intern("dropDisable")); \
+    FXRbCallVoidMethod(this,"dropDisable"); \
     }
 
 class FXRbWindow : public FXWindow {

data/ext/fox16_c/include/FXRuby.h

@@ -91,8 +91,10 @@ swig_type_info *FXRbTypeQuery(const char *name);
 void* FXRbConvertPtr(VALUE obj,swig_type_info* typeinfo);
 
 // Returns an FXInputHandle for this Ruby file object
-FXInputHandle FXRbGetReadFileHandle(VALUE obj);
-FXInputHandle FXRbGetWriteFileHandle(VALUE obj);
+FXInputHandle FXRbGetReadFileHandle(VALUE obj,FXuint mode);
+FXInputHandle FXRbGetWriteFileHandle(VALUE obj,FXuint mode);
+void FXRbRemoveReadFileHandle(VALUE obj,FXuint mode);
+void FXRbRemoveWriteFileHandle(VALUE obj,FXuint mode);
 
 // Register mapping from Ruby objects to FOX objects
 void FXRbRegisterRubyObj(VALUE rubyObj, const void* foxObj);
@@ -100,6 +102,13 @@ void FXRbRegisterRubyObj(VALUE rubyObj, const void* foxObj);
 // Remove mapping for this FOX object and zero out any pointers
 // to this (now dead) C++ object held by any Ruby object
 void FXRbUnregisterRubyObj(const void* foxObj);
+void FXRbUnregisterRubyObj2(const void* foxObj, bool alsoOwned=true);
+void FXRbUnregisterBorrowedRubyObj(const void* foxObj);
+void FXRbUnregisterBorrowedRubyObj(FXlong foxObj);
+void FXRbUnregisterBorrowedRubyObj(FXString& foxObj);
+void FXRbUnregisterBorrowedRubyObj(FXRegion& foxObj);
+void FXRbUnregisterBorrowedRubyObj(FXRectangle& foxObj);
+void FXRbUnregisterBorrowedRubyObj(FXDC& foxObj);
 
 // Register an object that must be destroyed before FXApp is destroyed
 void FXRbRegisterAppSensitiveObject(FXObject* obj);
@@ -168,10 +177,10 @@ extern FXColor *FXRbConvertToFXColors(VALUE string_or_ary, FXuint *opts);
 extern void* FXRbGetExpectedData(VALUE recv,FXSelector key,VALUE data);
 
 // Returns the name of the message handler function (or NULL)
-ID FXRbLookupHandler(FXObject* recv,FXSelector key);
+ID FXRbLookupHandler_gvlcb(FXObject* recv,FXSelector key);
 
 // Handle this message
-long FXRbHandleMessage(FXObject* recv,ID func,FXObject* sender,FXSelector key,void* data);
+long FXRbHandleMessage_gvlcb(FXObject* recv,ID func,FXObject* sender,FXSelector key,void* data);
 
 // Convert a signal name string to its corresponding signal number
 FXint FXRbSignalNameToNumber(const char* name);
@@ -351,324 +360,409 @@ void FXRbRange2LoHi(VALUE range,FXint& lo,FXint& hi);
 void FXRbRange2LoHi(VALUE range,FXdouble& lo,FXdouble& hi);
 
 // Call function with "void" return value
-void FXRbCallVoidMethod(FXObject* recv,ID func);
+void FXRbCallVoidMethod_gvlcb(FXObject* recv,const char *func);
 
-void FXRbCallVoidMethod(FXDC* recv,ID func);
+void FXRbCallVoidMethod_gvlcb(FXDC* recv,const char *func);
 
 /* One argument */
 template<class TYPE>
-void FXRbCallVoidMethod(FXObject* recv,ID func, TYPE& arg){
+void FXRbCallVoidMethod_gvlcb(FXObject* recv,const char *func, TYPE& arg){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
   FXASSERT(!FXRbIsInGC(recv));
-  rb_funcall(obj,func,1,to_ruby(arg));
+  rb_funcall(obj,rb_intern(func),1,to_ruby(arg));
+  FXRbUnregisterBorrowedRubyObj(&arg);
   }
 
 template<class TYPE>
-void FXRbCallVoidMethod(FXDC* recv,ID func,TYPE arg){
+void FXRbCallVoidMethod_gvlcb(FXDC* recv,const char *func,TYPE arg){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,1,to_ruby(arg));
+  rb_funcall(obj,rb_intern(func),1,to_ruby(arg));
+  FXRbUnregisterBorrowedRubyObj(arg);
   }
 
 template<class TYPE>
-void FXRbCallVoidMethod(const FXObject* recv, ID func, TYPE& arg){
+void FXRbCallVoidMethod_gvlcb(const FXObject* recv, const char *func, TYPE& arg){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
   FXASSERT(!FXRbIsInGC(recv));
-  rb_funcall(obj,func,1,to_ruby(arg));
+  rb_funcall(obj,rb_intern(func),1,to_ruby(arg));
+  FXRbUnregisterBorrowedRubyObj(&arg);
   }
 
 /* Two arguments */
 template<class TYPE1, class TYPE2>
-void FXRbCallVoidMethod(FXObject* recv,ID func,TYPE1 arg1,TYPE2 arg2){
+void FXRbCallVoidMethod_gvlcb(FXObject* recv,const char *func,TYPE1 arg1,TYPE2 arg2){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,2,to_ruby(arg1),to_ruby(arg2));
+  rb_funcall(obj,rb_intern(func),2,to_ruby(arg1),to_ruby(arg2));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
   }
 
 template<class TYPE1, class TYPE2>
-void FXRbCallVoidMethod(FXDC* recv,ID func,TYPE1 arg1,TYPE2 arg2){
+void FXRbCallVoidMethod_gvlcb(FXDC* recv,const char *func,TYPE1 arg1,TYPE2 arg2){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,2,to_ruby(arg1),to_ruby(arg2));
+  rb_funcall(obj,rb_intern(func),2,to_ruby(arg1),to_ruby(arg2));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
   }
 
-FXTreeItem* FXRbCallTreeItemMethod(const FXTreeList* recv,ID func,FXint x,FXint y);
-FXFoldingItem* FXRbCallFoldingItemMethod(const FXFoldingList* recv,ID func,FXint x,FXint y);
+template<class TYPE>
+void FXRbCallVoidArrayMethod(FXDC* recv,const char *func,TYPE objs,FXuint num){
+  VALUE obj=FXRbGetRubyObj(recv,false);
+  VALUE array=FXRbMakeArray(objs,num);
+  FXASSERT(!NIL_P(obj));
+  rb_funcall(obj,rb_intern(func),1,array);
+  for(FXuint i=0; i<num; i++)
+    FXRbUnregisterBorrowedRubyObj(&objs[i]);
+  }
+
+FXTreeItem* FXRbCallTreeItemMethod_gvlcb(const FXTreeList* recv,const char *func,FXint x,FXint y);
+FXFoldingItem* FXRbCallFoldingItemMethod_gvlcb(const FXFoldingList* recv,const char *func,FXint x,FXint y);
 
 /* Three arguments */
 template<class TYPE1, class TYPE2, class TYPE3>
-void FXRbCallVoidMethod(FXObject* recv,ID func,TYPE1 arg1,TYPE2 arg2,TYPE3 arg3){
+void FXRbCallVoidMethod_gvlcb(FXObject* recv,const char *func,TYPE1 arg1,TYPE2 arg2,TYPE3 arg3){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,3,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3));
+  rb_funcall(obj,rb_intern(func),3,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
   }
 
 template<class TYPE1, class TYPE2, class TYPE3>
-void FXRbCallVoidMethod(FXDC* recv,ID func,TYPE1 arg1,TYPE2 arg2,TYPE3 arg3){
+void FXRbCallVoidMethod_gvlcb(FXDC* recv,const char *func,TYPE1 arg1,TYPE2 arg2,TYPE3 arg3){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,3,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3));
+  rb_funcall(obj,rb_intern(func),3,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
   }
 
 /* Four arguments */
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4>
-void FXRbCallVoidMethod(FXObject* recv,ID func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4){
+void FXRbCallVoidMethod_gvlcb(FXObject* recv,const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,4,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4));
+  rb_funcall(obj,rb_intern(func),4,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
+  FXRbUnregisterBorrowedRubyObj(arg4);
   }
 
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4>
-void FXRbCallVoidMethod(FXDC* recv,ID func,TYPE1 arg1,TYPE2 arg2,TYPE3 arg3,TYPE4 arg4){
+void FXRbCallVoidMethod_gvlcb(FXDC* recv,const char *func,TYPE1 arg1,TYPE2 arg2,TYPE3 arg3,TYPE4 arg4){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,4,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4));
+  rb_funcall(obj,rb_intern(func),4,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
+  FXRbUnregisterBorrowedRubyObj(arg4);
   }
 
 /* Five arguments */
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4, class TYPE5>
-void FXRbCallVoidMethod(FXObject* recv,ID func,TYPE1& arg1,TYPE2 arg2,TYPE3 arg3,TYPE4 arg4,TYPE5 arg5){
+void FXRbCallVoidMethod_gvlcb(FXObject* recv,const char *func,TYPE1& arg1,TYPE2 arg2,TYPE3 arg3,TYPE4 arg4,TYPE5 arg5){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,5,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5));
+  rb_funcall(obj,rb_intern(func),5,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
+  FXRbUnregisterBorrowedRubyObj(arg4);
+  FXRbUnregisterBorrowedRubyObj(arg5);
   }
 
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4, class TYPE5>
-void FXRbCallVoidMethod(FXDC* recv, ID func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5){
+void FXRbCallVoidMethod_gvlcb(FXDC* recv, const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,5,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5));
+  rb_funcall(obj,rb_intern(func),5,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
+  FXRbUnregisterBorrowedRubyObj(arg4);
+  FXRbUnregisterBorrowedRubyObj(arg5);
   }
 
 /* Six arguments */
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4, class TYPE5, class TYPE6>
-void FXRbCallVoidMethod(const FXObject* recv, ID func, TYPE1 arg1, TYPE2& arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5, TYPE6 arg6){
+void FXRbCallVoidMethod_gvlcb(const FXObject* recv, const char *func, TYPE1 arg1, TYPE2& arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5, TYPE6 arg6){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,6,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6));
+  rb_funcall(obj,rb_intern(func),6,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
+  FXRbUnregisterBorrowedRubyObj(arg4);
+  FXRbUnregisterBorrowedRubyObj(arg5);
+  FXRbUnregisterBorrowedRubyObj(arg6);
   }
 
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4, class TYPE5, class TYPE6>
-void FXRbCallVoidMethod(FXDC* recv, ID func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5, TYPE6 arg6){
+void FXRbCallVoidMethod_gvlcb(FXDC* recv, const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5, TYPE6 arg6){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,6,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6));
+  rb_funcall(obj,rb_intern(func),6,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
+  FXRbUnregisterBorrowedRubyObj(arg4);
+  FXRbUnregisterBorrowedRubyObj(arg5);
+  FXRbUnregisterBorrowedRubyObj(arg6);
   }
 
 /* Seven arguments */
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4, class TYPE5, class TYPE6, class TYPE7>
-void FXRbCallVoidMethod(FXDC* recv, ID func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5, TYPE6 arg6, TYPE7 arg7){
+void FXRbCallVoidMethod_gvlcb(FXDC* recv, const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5, TYPE6 arg6, TYPE7 arg7){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,7,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6),to_ruby(arg7));
+  rb_funcall(obj,rb_intern(func),7,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6),to_ruby(arg7));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
+  FXRbUnregisterBorrowedRubyObj(arg4);
+  FXRbUnregisterBorrowedRubyObj(arg5);
+  FXRbUnregisterBorrowedRubyObj(arg6);
+  FXRbUnregisterBorrowedRubyObj(arg7);
   }
 
 /* Nine arguments */
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4, class TYPE5, class TYPE6, class TYPE7, class TYPE8, class TYPE9>
-void FXRbCallVoidMethod(FXDC* recv, ID func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5, TYPE6 arg6, TYPE7 arg7, TYPE8 arg8, TYPE9 arg9){
+void FXRbCallVoidMethod_gvlcb(FXDC* recv, const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5, TYPE6 arg6, TYPE7 arg7, TYPE8 arg8, TYPE9 arg9){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,9,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6),to_ruby(arg7), to_ruby(arg8), to_ruby(arg9));
+  rb_funcall(obj,rb_intern(func),9,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6),to_ruby(arg7), to_ruby(arg8), to_ruby(arg9));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
+  FXRbUnregisterBorrowedRubyObj(arg4);
+  FXRbUnregisterBorrowedRubyObj(arg5);
+  FXRbUnregisterBorrowedRubyObj(arg6);
+  FXRbUnregisterBorrowedRubyObj(arg7);
+  FXRbUnregisterBorrowedRubyObj(arg8);
+  FXRbUnregisterBorrowedRubyObj(arg9);
   }
 
 /* Eleven arguments (!) */
 template<class TYPE1,class TYPE2,class TYPE3,class TYPE4,class TYPE5,class TYPE6,class TYPE7,class TYPE8,class TYPE9,class TYPE10,class TYPE11>
-void FXRbCallVoidMethod(FXObject* recv,ID func,TYPE1& arg1,TYPE2 arg2,TYPE3 arg3,TYPE4 arg4,TYPE5 arg5,TYPE6 arg6,TYPE7 arg7,TYPE8 arg8,TYPE9 arg9,TYPE10 arg10,TYPE11 arg11){
+void FXRbCallVoidMethod_gvlcb(FXObject* recv,const char *func,TYPE1& arg1,TYPE2 arg2,TYPE3 arg3,TYPE4 arg4,TYPE5 arg5,TYPE6 arg6,TYPE7 arg7,TYPE8 arg8,TYPE9 arg9,TYPE10 arg10,TYPE11 arg11){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,11,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6),to_ruby(arg7),to_ruby(arg8),to_ruby(arg9),to_ruby(arg10),to_ruby(arg11));
+  rb_funcall(obj,rb_intern(func),11,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5),to_ruby(arg6),to_ruby(arg7),to_ruby(arg8),to_ruby(arg9),to_ruby(arg10),to_ruby(arg11));
+  FXRbUnregisterBorrowedRubyObj(arg1);
+  FXRbUnregisterBorrowedRubyObj(arg2);
+  FXRbUnregisterBorrowedRubyObj(arg3);
+  FXRbUnregisterBorrowedRubyObj(arg4);
+  FXRbUnregisterBorrowedRubyObj(arg5);
+  FXRbUnregisterBorrowedRubyObj(arg6);
+  FXRbUnregisterBorrowedRubyObj(arg7);
+  FXRbUnregisterBorrowedRubyObj(arg8);
+  FXRbUnregisterBorrowedRubyObj(arg9);
+  FXRbUnregisterBorrowedRubyObj(arg10);
+  FXRbUnregisterBorrowedRubyObj(arg11);
   }
 
 // Call function with "FXbool" return value
-inline bool FXRbCallBoolMethod(FXStream* recv,ID func){
-  VALUE v=rb_funcall(FXRbGetRubyObj(recv,false),func,0,NULL);
+inline bool FXRbCallBoolMethod_gvlcb(FXStream* recv,const char *func){
+  VALUE v=rb_funcall(FXRbGetRubyObj(recv,false),rb_intern(func),0,NULL);
   return (v==Qtrue);
   }
 
 template<class TYPE1>
-bool FXRbCallBoolMethod(FXStream* recv,ID func,TYPE1 arg){
-  VALUE v=rb_funcall(FXRbGetRubyObj(recv,false),func,1,to_ruby(arg));
+bool FXRbCallBoolMethod_gvlcb(FXStream* recv,const char *func,TYPE1 arg){
+  VALUE v=rb_funcall(FXRbGetRubyObj(recv,false),rb_intern(func),1,to_ruby(arg));
   return (v==Qtrue);
   }
 
 template<class TYPE1,class TYPE2>
-bool FXRbCallBoolMethod(FXStream* recv,ID func,TYPE1 arg1,TYPE2 arg2){
-  VALUE v=rb_funcall(FXRbGetRubyObj(recv,false),func,2,to_ruby(arg1),to_ruby(arg2));
+bool FXRbCallBoolMethod_gvlcb(FXStream* recv,const char *func,TYPE1 arg1,TYPE2 arg2){
+  VALUE v=rb_funcall(FXRbGetRubyObj(recv,false),rb_intern(func),2,to_ruby(arg1),to_ruby(arg2));
   return (v==Qtrue);
   }
 
-bool FXRbCallBoolMethod(const FXObject* recv,ID func);
+bool FXRbCallBoolMethod_gvlcb(const FXObject* recv,const char *func);
 
 template<class TYPE>
-bool FXRbCallBoolMethod(FXObject* recv, ID func, TYPE& arg){
+bool FXRbCallBoolMethod_gvlcb(FXObject* recv, const char *func, TYPE& arg){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,1,to_ruby(arg));
+  VALUE v=rb_funcall(obj,rb_intern(func),1,to_ruby(arg));
   return (v==Qtrue);
   }
 
 template<class TYPE>
-bool FXRbCallBoolMethod(const FXObject* recv,ID func,TYPE& arg){
-  VALUE v=rb_funcall(FXRbGetRubyObj(recv,false),func,1,to_ruby(arg));
+bool FXRbCallBoolMethod_gvlcb(const FXObject* recv,const char *func,TYPE& arg){
+  VALUE v=rb_funcall(FXRbGetRubyObj(recv,false),rb_intern(func),1,to_ruby(arg));
   return (v==Qtrue);
   }
 
 template<class TYPE1, class TYPE2>
-bool FXRbCallBoolMethod(const FXObject* recv, ID func, TYPE1 arg1, TYPE2 arg2){
+bool FXRbCallBoolMethod_gvlcb(const FXObject* recv, const char *func, TYPE1 arg1, TYPE2 arg2){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,2,to_ruby(arg1),to_ruby(arg2));
+  VALUE v=rb_funcall(obj,rb_intern(func),2,to_ruby(arg1),to_ruby(arg2));
   return (v==Qtrue);
   }
 
 template<class TYPE1, class TYPE2, class TYPE3>
-bool FXRbCallBoolMethod(const FXObject* recv, ID func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3){
+bool FXRbCallBoolMethod_gvlcb(const FXObject* recv, const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,3,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3));
+  VALUE v=rb_funcall(obj,rb_intern(func),3,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3));
   return (v==Qtrue);
   }
 
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4, class TYPE5>
-bool FXRbCallBoolMethod(const FXObject* recv, ID func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5){
+bool FXRbCallBoolMethod_gvlcb(const FXObject* recv, const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,5,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5));
+  VALUE v=rb_funcall(obj,rb_intern(func),5,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5));
   return (v==Qtrue);
   }
 
 // Call function with "FXint" return value
-FXint FXRbCallIntMethod(const FXObject* recv,ID func);
+FXint FXRbCallIntMethod_gvlcb(const FXObject* recv,const char *func);
 
 template<class TYPE>
-FXint FXRbCallIntMethod(FXObject* recv, ID func, TYPE arg){
+FXint FXRbCallIntMethod_gvlcb(FXObject* recv, const char *func, TYPE arg){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,1,to_ruby(arg));
+  VALUE v=rb_funcall(obj,rb_intern(func),1,to_ruby(arg));
   return static_cast<FXint>(NUM2INT(v));
   }
 
 template<class TYPE>
-FXint FXRbCallIntMethod(const FXObject* recv, ID func, TYPE arg){
+FXint FXRbCallIntMethod_gvlcb(const FXObject* recv, const char *func, TYPE arg){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,1,to_ruby(arg));
+  VALUE v=rb_funcall(obj,rb_intern(func),1,to_ruby(arg));
   return static_cast<FXint>(NUM2INT(v));
   }
 
 template<class TYPE1, class TYPE2>
-FXint FXRbCallIntMethod(const FXObject* recv, ID func, TYPE1 arg1, TYPE2 arg2){
+FXint FXRbCallIntMethod_gvlcb(const FXObject* recv, const char *func, TYPE1 arg1, TYPE2 arg2){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,2,to_ruby(arg1),to_ruby(arg2));
+  VALUE result=rb_funcall(obj,rb_intern(func),2,to_ruby(arg1),to_ruby(arg2));
   return static_cast<FXint>(NUM2INT(result));
   }
 
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4, class TYPE5>
-FXint FXRbCallIntMethod(const FXObject* recv, ID func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5){
+FXint FXRbCallIntMethod_gvlcb(const FXObject* recv, const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,5,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5));
+  VALUE result=rb_funcall(obj,rb_intern(func),5,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4),to_ruby(arg5));
   return static_cast<FXint>(NUM2INT(result));
   }
 
 // Call function with "long" return value
 template<class TYPE1, class TYPE2, class TYPE3>
-long FXRbCallLongMethod(FXObject* recv, ID func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3){
+long FXRbCallLongMethod_gvlcb(FXObject* recv, const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,3,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3));
+  VALUE v=rb_funcall(obj,rb_intern(func),3,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3));
   return static_cast<long>(NUM2LONG(v));
   }
 
 // Call functions with "FXuint" return value
 template<class TYPE>
-FXuint FXRbCallUIntMethod(FXObject* recv, ID func, TYPE arg){
+FXuint FXRbCallUIntMethod_gvlcb(FXObject* recv, const char *func, TYPE arg){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,1,to_ruby(arg));
+  VALUE v=rb_funcall(obj,rb_intern(func),1,to_ruby(arg));
   return static_cast<FXuint>(NUM2UINT(v));
   }
 
 // Call functions with FXString return value
-FXString FXRbCallStringMethod(const FXObject* recv, ID func);
+FXString FXRbCallStringMethod_gvlcb(const FXObject* recv, const char *func);
 
 // Call functions with const FXchar* return value
-const FXchar* FXRbCallCStringMethod(const FXObject* recv, ID func, const FXchar*, const FXchar*);
-const FXchar* FXRbCallCStringMethod(const FXObject* recv, ID func, const FXchar*, const FXchar*, const FXchar*);
+const FXchar* FXRbCallCStringMethod_gvlcb(const FXObject* recv, const char *func, const FXchar*, const FXchar*);
+const FXchar* FXRbCallCStringMethod_gvlcb(const FXObject* recv, const char *func, const FXchar*, const FXchar*, const FXchar*);
 
 // Call functions with "FXGLObject*" return value
-FXGLObject* FXRbCallGLObjectMethod(FXGLObject* recv,ID func);
-FXGLObject* FXRbCallGLObjectMethod(FXGLObject* recv,ID func,FXuint* path,FXint n);
-FXGLObject* FXRbCallGLObjectMethod(FXGLViewer* recv,ID func,FXint x,FXint y);
+FXGLObject* FXRbCallGLObjectMethod_gvlcb(FXGLObject* recv,const char *func);
+FXGLObject* FXRbCallGLObjectMethod_gvlcb(FXGLObject* recv,const char *func,FXuint* path,FXint n);
+FXGLObject* FXRbCallGLObjectMethod_gvlcb(FXGLViewer* recv,const char *func,FXint x,FXint y);
 
 // Call functions with "FXGLObject**" return value
-FXGLObject** FXRbCallGLObjectArrayMethod(FXGLViewer* recv,ID func,FXint x,FXint y,FXint w,FXint h);
+FXGLObject** FXRbCallGLObjectArrayMethod_gvlcb(FXGLViewer* recv,const char *func,FXint x,FXint y,FXint w,FXint h);
 
 // Call functions with "FXTreeItem*" return value
-FXTableItem* FXRbCallTableItemMethod(FXTable* recv,ID func,const FXString& text,FXIcon* icon,void* ptr);
+FXTableItem* FXRbCallTableItemMethod_gvlcb(FXTable* recv,const char *func,const FXString& text,FXIcon* icon,void* ptr);
 
 // Call functions with "FXTreeItem*" return value
-FXTableItem* FXRbCallTableItemMethod(FXTable* recv,ID func,FXint,FXint,FXbool);
+FXTableItem* FXRbCallTableItemMethod_gvlcb(FXTable* recv,const char *func,FXint,FXint,FXbool);
 
 // Call functions with "FXFileAssoc*" return value
-FXFileAssoc* FXRbCallFileAssocMethod(const FXFileDict* recv,ID func,const FXchar* pathname);
+FXFileAssoc* FXRbCallFileAssocMethod_gvlcb(const FXFileDict* recv,const char *func,const FXchar* pathname);
 
 // Call functions with "FXIcon*" return value
-FXIcon* FXRbCallIconMethod(const FXTableItem* recv,ID func);
+FXIcon* FXRbCallIconMethod_gvlcb(const FXTableItem* recv,const char *func);
 
 template<class TYPE1, class TYPE2>
-FXIcon* FXRbCallIconMethod(const FXIconSource *recv,ID func,TYPE1& arg1,const TYPE2& arg2){
+FXIcon* FXRbCallIconMethod_gvlcb(const FXIconSource *recv,const char *func,TYPE1& arg1,const TYPE2& arg2){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,2,to_ruby(arg1),to_ruby(arg2));
+  VALUE result=rb_funcall(obj,rb_intern(func),2,to_ruby(arg1),to_ruby(arg2));
   return NIL_P(result) ? 0 : reinterpret_cast<FXIcon*>(DATA_PTR(result));
   }
 
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4>
-FXIcon* FXRbCallIconMethod(const FXIconSource *recv,ID func,TYPE1& arg1,TYPE2 arg2,TYPE3 arg3,const TYPE4& arg4){
+FXIcon* FXRbCallIconMethod_gvlcb(const FXIconSource *recv,const char *func,TYPE1& arg1,TYPE2 arg2,TYPE3 arg3,const TYPE4& arg4){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,4,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4));
+  VALUE result=rb_funcall(obj,rb_intern(func),4,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4));
   return NIL_P(result) ? 0 : reinterpret_cast<FXIcon*>(DATA_PTR(result));
   }
 
 // Call functions with FXImage* return value
 template<class TYPE1, class TYPE2>
-FXImage* FXRbCallImageMethod(const FXIconSource *recv,ID func,TYPE1& arg1,const TYPE2& arg2){
+FXImage* FXRbCallImageMethod_gvlcb(const FXIconSource *recv,const char *func,TYPE1& arg1,const TYPE2& arg2){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,2,to_ruby(arg1),to_ruby(arg2));
+  VALUE result=rb_funcall(obj,rb_intern(func),2,to_ruby(arg1),to_ruby(arg2));
   return NIL_P(result) ? 0 : reinterpret_cast<FXImage*>(DATA_PTR(result));
   }
 
 template<class TYPE1, class TYPE2, class TYPE3, class TYPE4>
-FXImage* FXRbCallImageMethod(const FXIconSource *recv,ID func,TYPE1& arg1,TYPE2 arg2,TYPE3 arg3,const TYPE4& arg4){
+FXImage* FXRbCallImageMethod_gvlcb(const FXIconSource *recv,const char *func,TYPE1& arg1,TYPE2 arg2,TYPE3 arg3,const TYPE4& arg4){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,4,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4));
+  VALUE result=rb_funcall(obj,rb_intern(func),4,to_ruby(arg1),to_ruby(arg2),to_ruby(arg3),to_ruby(arg4));
   return NIL_P(result) ? 0 : reinterpret_cast<FXImage*>(DATA_PTR(result));
   }
 
 // Call functions with "FXWindow*" return value
-FXWindow* FXRbCallWindowMethod(const FXTableItem* recv,ID func,FXTable* table);
+FXWindow* FXRbCallWindowMethod_gvlcb(const FXTableItem* recv,const char *func,FXTable* table);
 
 // Call functions with "FXColor" return value
 template<class TYPE1, class TYPE2>
-FXColor FXRbCallColorMethod(FXDC* recv, ID func, TYPE1 arg1, TYPE2 arg2){
+FXColor FXRbCallColorMethod_gvlcb(FXDC* recv, const char *func, TYPE1 arg1, TYPE2 arg2){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,2,to_ruby(arg1),to_ruby(arg2));
+  VALUE v=rb_funcall(obj,rb_intern(func),2,to_ruby(arg1),to_ruby(arg2));
   return static_cast<FXColor>(NUM2UINT(v));
   }
 
 // Call functions with "FXRangef" return value
-FXRangef FXRbCallRangeMethod(FXObject* recv,ID func);
+FXRangef FXRbCallRangeMethod_gvlcb(FXObject* recv,const char *func);
 
 // Call functions with FXwchar return value
-FXwchar FXRbCallWCharMethod(const FXObject* recv,ID func);
+FXwchar FXRbCallWCharMethod_gvlcb(const FXObject* recv,const char *func);
+
+void FXRbCallSetDashes_gvlcb(FXDC* recv,const char *func,FXuint dashoffset,const FXchar *dashpattern,FXuint dashlength);
+
+void FXRbCallDCDrawMethod_gvlcb(FXDC* recv, const char * func, FXint x,FXint y,const FXString& string);
+void FXRbCallDCDrawMethod_gvlcb(FXDC* recv, const char * func, FXint x,FXint y,const FXchar* string,FXuint length);
 
 /**
  * Macro to set up class implementation.
@@ -694,6 +788,18 @@ FXwchar FXRbCallWCharMethod(const FXObject* recv,ID func);
     }
 
 
+#define SORTFUNC(list, item) \
+  FXint list##_sortFunc_gvlcb(const item* a,const item* b);
+
+SORTFUNC( FXRbComboBox, FXListItem )
+SORTFUNC( FXRbFoldingList, FXFoldingItem )
+SORTFUNC( FXRbIconList, FXIconItem )
+SORTFUNC( FXRbList, FXListItem )
+SORTFUNC( FXRbListBox, FXListItem )
+SORTFUNC( FXRbTreeList, FXTreeItem )
+
+#undef SORTFUNC
+
 // FXRuby classes
 #include "FXRbStream.h"
 #include "FXRbObject.h"