fxruby 1.6.29-x64-mingw32 → 1.6.30-x64-mingw32

data/ext/fox16_c/include/FXRbIconSource.h

@@ -68,40 +68,40 @@ inline FXImage* cls ## _loadScaledImageStream(const cls* self,FXStream& store,FX
 
 #define IMPLEMENT_FXICONSOURCE_STUBS(cls) \
   FXIcon* cls::loadIconFile(const FXString& filename,const FXString& type) const { \
-    return FXRbCallIconMethod(this,rb_intern("loadIconFile"),filename,type); \
+    return FXRbCallIconMethod(this,"loadIconFile",filename,type); \
     } \
   FXIcon* cls::loadIconData(const void* pixels,const FXString& type) const { \
-    return FXRbCallIconMethod(this,rb_intern("loadIconData"),pixels,type); \
+    return FXRbCallIconMethod(this,"loadIconData",pixels,type); \
     } \
   FXIcon* cls::loadIconStream(FXStream& store,const FXString& type) const { \
-    return FXRbCallIconMethod(this,rb_intern("loadIconStream"),store,type); \
+    return FXRbCallIconMethod(this,"loadIconStream",store,type); \
     } \
   FXImage* cls::loadImageFile(const FXString& filename,const FXString& type) const { \
-    return FXRbCallImageMethod(this,rb_intern("loadImageFile"),filename,type); \
+    return FXRbCallImageMethod(this,"loadImageFile",filename,type); \
     } \
   FXImage* cls::loadImageData(const void* pixels,const FXString& type) const { \
-    return FXRbCallImageMethod(this,rb_intern("loadImageData"),pixels,type); \
+    return FXRbCallImageMethod(this,"loadImageData",pixels,type); \
     } \
   FXImage* cls::loadImageStream(FXStream& store,const FXString& type) const { \
-    return FXRbCallImageMethod(this,rb_intern("loadImageStream"),store,type); \
+    return FXRbCallImageMethod(this,"loadImageStream",store,type); \
     } \
   FXIcon* cls::loadScaledIconFile(const FXString& filename,FXint size,FXint qual,const FXString& type) const { \
-    return FXRbCallIconMethod(this,rb_intern("loadScaledIconFile"),filename,size,qual,type); \
+    return FXRbCallIconMethod(this,"loadScaledIconFile",filename,size,qual,type); \
     } \
   FXIcon* cls::loadScaledIconData(const void* pixels,FXint size,FXint qual,const FXString& type) const { \
-    return FXRbCallIconMethod(this,rb_intern("loadScaledIconData"),pixels,size,qual,type); \
+    return FXRbCallIconMethod(this,"loadScaledIconData",pixels,size,qual,type); \
     } \
   FXIcon* cls::loadScaledIconStream(FXStream& store,FXint size,FXint qual,const FXString& type) const { \
-    return FXRbCallIconMethod(this,rb_intern("loadScaledIconStream"),store,size,qual,type); \
+    return FXRbCallIconMethod(this,"loadScaledIconStream",store,size,qual,type); \
     } \
   FXImage* cls::loadScaledImageFile(const FXString& filename,FXint size,FXint qual,const FXString& type) const { \
-    return FXRbCallImageMethod(this,rb_intern("loadScaledImageFile"),filename,size,qual,type); \
+    return FXRbCallImageMethod(this,"loadScaledImageFile",filename,size,qual,type); \
     } \
   FXImage* cls::loadScaledImageData(const void* pixels,FXint size,FXint qual,const FXString& type) const { \
-    return FXRbCallImageMethod(this,rb_intern("loadScaledImageData"),pixels,size,qual,type); \
+    return FXRbCallImageMethod(this,"loadScaledImageData",pixels,size,qual,type); \
     } \
   FXImage* cls::loadScaledImageStream(FXStream& store,FXint size,FXint qual,const FXString& type) const { \
-    return FXRbCallImageMethod(this,rb_intern("loadScaledImageStream"),store,size,qual,type); \
+    return FXRbCallImageMethod(this,"loadScaledImageStream",store,size,qual,type); \
     }
 
 

data/ext/fox16_c/include/FXRbId.h

@@ -41,13 +41,13 @@ inline void klass ## _destroy(klass* self){ \
 
 #define IMPLEMENT_FXID_STUBS(cls) \
   void cls::create(){ \
-    FXRbCallVoidMethod(this,rb_intern("create")); \
+    FXRbCallVoidMethod(this,"create"); \
     } \
   void cls::detach(){ \
-    FXRbCallVoidMethod(this,rb_intern("detach")); \
+    FXRbCallVoidMethod(this,"detach"); \
     } \
   void cls::destroy(){ \
-    FXRbCallVoidMethod(this,rb_intern("destroy")); \
+    FXRbCallVoidMethod(this,"destroy"); \
     }
 
 

data/ext/fox16_c/include/FXRbImage.h

@@ -73,65 +73,65 @@ inline void klass ## _gradient(klass* self,FXColor topleft,FXColor topright,FXCo
 inline void klass ## _blend(klass* self,FXColor color){ \
   self->klass::blend(color); \
   } \
-inline bool klass ## _savePixels(const klass* self,FXStream& store){ \
+inline bool klass ## _savePixels_gvl(const klass* self,FXStream& store){ \
   return self->klass::savePixels(store); \
   } \
-inline bool klass ## _loadPixels(klass* self,FXStream& store){ \
+inline bool klass ## _loadPixels_gvl(klass* self,FXStream& store){ \
   return self->klass::loadPixels(store); \
   }
 
 
 #define IMPLEMENT_FXIMAGE_STUBS(cls) \
   void cls::restore(){ \
-    FXRbCallVoidMethod(this,rb_intern("restore")); \
+    FXRbCallVoidMethod(this,"restore"); \
     } \
   void cls::render(){ \
-    FXRbCallVoidMethod(this,rb_intern("render")); \
+    FXRbCallVoidMethod(this,"render"); \
     } \
   void cls::release(){ \
-    FXRbCallVoidMethod(this,rb_intern("release")); \
+    FXRbCallVoidMethod(this,"release"); \
     } \
   void cls::scale(FXint w,FXint h,FXint quality){ \
-    FXRbCallVoidMethod(this,rb_intern("scale"),w,h,quality); \
+    FXRbCallVoidMethod(this,"scale",w,h,quality); \
     } \
   void cls::mirror(bool horizontal,bool vertical){ \
-    FXRbCallVoidMethod(this,rb_intern("mirror"),horizontal,vertical); \
+    FXRbCallVoidMethod(this,"mirror",horizontal,vertical); \
     } \
   void cls::rotate(FXint degrees){ \
-    FXRbCallVoidMethod(this,rb_intern("rotate"),degrees); \
+    FXRbCallVoidMethod(this,"rotate",degrees); \
     } \
   void cls::crop(FXint x,FXint y,FXint w,FXint h,FXColor color){ \
-    FXRbCallVoidMethod(this,rb_intern("crop"),x,y,w,h,color); \
+    FXRbCallVoidMethod(this,"crop",x,y,w,h,color); \
     } \
   void cls::fill(FXColor color){ \
-    FXRbCallVoidMethod(this,rb_intern("fill"),color); \
+    FXRbCallVoidMethod(this,"fill",color); \
     } \
   void cls::fade(FXColor color,FXint factor){ \
-    FXRbCallVoidMethod(this,rb_intern("fade"),color,factor); \
+    FXRbCallVoidMethod(this,"fade",color,factor); \
     } \
   void cls::xshear(FXint shear,FXColor clr){ \
-    FXRbCallVoidMethod(this,rb_intern("xshear"),shear,clr); \
+    FXRbCallVoidMethod(this,"xshear",shear,clr); \
     } \
   void cls::yshear(FXint shear,FXColor clr){ \
-    FXRbCallVoidMethod(this,rb_intern("yshear"),shear,clr); \
+    FXRbCallVoidMethod(this,"yshear",shear,clr); \
     } \
   void cls::hgradient(FXColor left,FXColor right){ \
-    FXRbCallVoidMethod(this,rb_intern("hgradient"),left,right); \
+    FXRbCallVoidMethod(this,"hgradient",left,right); \
     } \
   void cls::vgradient(FXColor top,FXColor bottom){ \
-    FXRbCallVoidMethod(this,rb_intern("vgradient"),top,bottom); \
+    FXRbCallVoidMethod(this,"vgradient",top,bottom); \
     } \
   void cls::gradient(FXColor topleft,FXColor topright,FXColor bottomleft,FXColor bottomright){ \
-    FXRbCallVoidMethod(this,rb_intern("gradient"),topleft,topright,bottomleft,bottomright); \
+    FXRbCallVoidMethod(this,"gradient",topleft,topright,bottomleft,bottomright); \
     } \
   void cls::blend(FXColor color){ \
-    FXRbCallVoidMethod(this,rb_intern("blend"),color); \
+    FXRbCallVoidMethod(this,"blend",color); \
     } \
   bool cls::savePixels(FXStream& store) const { \
-    return FXRbCallBoolMethod(this,rb_intern("savePixels"),store); \
+    return FXRbCallBoolMethod(this,"savePixels",store); \
     } \
   bool cls::loadPixels(FXStream& store){ \
-    return FXRbCallBoolMethod(this,rb_intern("loadPixels"),store); \
+    return FXRbCallBoolMethod(this,"loadPixels",store); \
     }
 
 

data/ext/fox16_c/include/FXRbList.h

@@ -65,37 +65,37 @@ inline FXint klass ## _getHeight(const klass* self,const FXList* list){ \
 
 #define IMPLEMENT_FXLISTITEM_STUBS(cls) \
   void cls::create(){ \
-    FXRbCallVoidMethod(this,rb_intern("create")); \
+    FXRbCallVoidMethod(this,"create"); \
     } \
   void cls::detach(){ \
-    FXRbCallVoidMethod(this,rb_intern("detach")); \
+    FXRbCallVoidMethod(this,"detach"); \
     } \
   void cls::destroy(){ \
-    FXRbCallVoidMethod(this,rb_intern("destroy")); \
+    FXRbCallVoidMethod(this,"destroy"); \
     } \
   void cls::setText(const FXString& txt){ \
-    FXRbCallVoidMethod(this,rb_intern("setText"),txt); \
+    FXRbCallVoidMethod(this,"setText",txt); \
     } \
   void cls::setIcon(FXIcon* icn,FXbool owned){ \
-    FXRbCallVoidMethod(this,rb_intern("setIcon"),icn,owned); \
+    FXRbCallVoidMethod(this,"setIcon",icn,owned); \
     } \
   void cls::setFocus(FXbool focus){ \
-    FXRbCallVoidMethod(this,rb_intern("setFocus"),focus); \
+    FXRbCallVoidMethod(this,"setFocus",focus); \
     } \
   void cls::setSelected(FXbool selected){ \
-    FXRbCallVoidMethod(this,rb_intern("setSelected"),selected); \
+    FXRbCallVoidMethod(this,"setSelected",selected); \
     } \
   void cls::setEnabled(FXbool enabled){ \
-    FXRbCallVoidMethod(this,rb_intern("setEnabled"),enabled); \
+    FXRbCallVoidMethod(this,"setEnabled",enabled); \
     } \
   void cls::setDraggable(FXbool draggable){ \
-    FXRbCallVoidMethod(this,rb_intern("setDraggable"),draggable); \
+    FXRbCallVoidMethod(this,"setDraggable",draggable); \
     } \
   FXint cls::getWidth(const FXList* list) const { \
-    return FXRbCallIntMethod(this,rb_intern("getWidth"),list); \
+    return FXRbCallIntMethod(this,"getWidth",list); \
     } \
   FXint cls::getHeight(const FXList* list) const { \
-    return FXRbCallIntMethod(this,rb_intern("getHeight"),list); \
+    return FXRbCallIntMethod(this,"getHeight",list); \
     }
 
 
@@ -160,34 +160,34 @@ inline void klass ## _setCurrentItem(klass* self,FXint index,FXbool notify){ \
 
 #define IMPLEMENT_FXLIST_STUBS(cls) \
   FXbool cls::enableItem(FXint index){ \
-    return FXRbCallBoolMethod(this,rb_intern("enableItem"),index); \
+    return FXRbCallBoolMethod(this,"enableItem",index); \
     } \
   FXbool cls::disableItem(FXint index){ \
-    return FXRbCallBoolMethod(this,rb_intern("disableItem"),index); \
+    return FXRbCallBoolMethod(this,"disableItem",index); \
     } \
   void cls::makeItemVisible(FXint index) { \
-    FXRbCallVoidMethod(this,rb_intern("makeItemVisible"),index); \
+    FXRbCallVoidMethod(this,"makeItemVisible",index); \
     } \
   FXint cls::getItemAt(FXint x,FXint y) const { \
-    return FXRbCallIntMethod(this,rb_intern("getItemAt"),x,y); \
+    return FXRbCallIntMethod(this,"getItemAt",x,y); \
     } \
   FXbool cls::selectItem(FXint index,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("selectItem"),index,notify); \
+    return FXRbCallBoolMethod(this,"selectItem",index,notify); \
     } \
   FXbool cls::deselectItem(FXint index,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("deselectItem"),index,notify); \
+    return FXRbCallBoolMethod(this,"deselectItem",index,notify); \
     } \
   FXbool cls::toggleItem(FXint index,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("toggleItem"),index,notify); \
+    return FXRbCallBoolMethod(this,"toggleItem",index,notify); \
     } \
   FXbool cls::extendSelection(FXint index,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("extendSelection"),index,notify); \
+    return FXRbCallBoolMethod(this,"extendSelection",index,notify); \
     } \
   FXbool cls::killSelection(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("killSelection"),notify); \
+    return FXRbCallBoolMethod(this,"killSelection",notify); \
     } \
   void cls::setCurrentItem(FXint index,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setCurrentItem"),index,notify); \
+    FXRbCallVoidMethod(this,"setCurrentItem",index,notify); \
     }
 
 

data/ext/fox16_c/include/FXRbListBox.h

@@ -34,7 +34,7 @@ inline void klass ## _setCurrentItem(klass* self,FXint index,FXbool notify){ \
 
 #define IMPLEMENT_FXLISTBOX_STUBS(cls) \
   void cls::setCurrentItem(FXint index,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setCurrentItem"),index,notify); \
+    FXRbCallVoidMethod(this,"setCurrentItem",index,notify); \
     }
 
 class FXRbListBox : public FXListBox {

data/ext/fox16_c/include/FXRbMDIChild.h

@@ -44,16 +44,16 @@ inline FXbool klass ## _close(klass* self,FXbool notify){ \
 
 #define IMPLEMENT_FXMDICHILD_STUBS(cls) \
   FXbool cls::minimize(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("minimize"),notify); \
+    return FXRbCallBoolMethod(this,"minimize",notify); \
     } \
   FXbool cls::maximize(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("maximize"),notify); \
+    return FXRbCallBoolMethod(this,"maximize",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/FXRbMDIClient.h

@@ -43,16 +43,16 @@
 
 #define IMPLEMENT_FXMDICLIENT_STUBS(cls) \
   FXbool cls::setActiveChild(FXMDIChild* child,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("setActiveChild"),child,notify); \
+    return FXRbCallBoolMethod(this,"setActiveChild",child,notify); \
     } \
   void cls::cascade(FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("cascade"),notify); \
+    FXRbCallVoidMethod(this,"cascade",notify); \
     } \
   void cls::horizontal(FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("horizontal"),notify); \
+    FXRbCallVoidMethod(this,"horizontal",notify); \
     } \
   void cls::vertical(FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("vertical"),notify); \
+    FXRbCallVoidMethod(this,"vertical",notify); \
     }
 
 class FXRbMDIClient : public FXMDIClient {

data/ext/fox16_c/include/FXRbObject.h

@@ -38,10 +38,10 @@ inline void cls ## _load(cls* self,FXStream& store){ \
 
 #define IMPLEMENT_FXOBJECT_STUBS(cls) \
   void cls::save(FXStream& store) const { \
-    FXRbCallVoidMethod(this,rb_intern("save"),store); \
+    FXRbCallVoidMethod(this,"save",store); \
     } \
   void cls::load(FXStream& store){ \
-    FXRbCallVoidMethod(this,rb_intern("load"),store); \
+    FXRbCallVoidMethod(this,"load",store); \
     }
 
 

data/ext/fox16_c/include/FXRbPopup.h

@@ -38,10 +38,10 @@ inline void klass ## _popdown(klass* self){ \
 
 #define IMPLEMENT_FXPOPUP_STUBS(cls) \
   void cls::popup(FXWindow* grabto,FXint x,FXint y,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("popup"),grabto,x,y,w,h); \
+    FXRbCallVoidMethod(this,"popup",grabto,x,y,w,h); \
     } \
   void cls::popdown(){ \
-    FXRbCallVoidMethod(this,rb_intern("popdown")); \
+    FXRbCallVoidMethod(this,"popdown"); \
     }
 
 

data/ext/fox16_c/include/FXRbRealSpinner.h

@@ -35,7 +35,7 @@ inline void klass ## _setValue(klass* self,FXdouble value,FXbool notify){ \
 
 #define IMPLEMENT_FXREALSPINNER_STUBS(cls) \
   void cls::setValue(FXdouble value,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setValue"),value,notify); \
+    FXRbCallVoidMethod(this,"setValue",value,notify); \
     }
 
 

data/ext/fox16_c/include/FXRbScrollArea.h

@@ -44,16 +44,16 @@ inline FXint klass ## _getViewportHeight(klass* self){ \
 
 #define IMPLEMENT_FXSCROLLAREA_STUBS(cls) \
   FXint cls::getContentWidth(){ \
-    return FXRbCallIntMethod(this,rb_intern("getContentWidth")); \
+    return FXRbCallIntMethod(this,"getContentWidth"); \
     } \
   FXint cls::getContentHeight(){ \
-    return FXRbCallIntMethod(this,rb_intern("getContentHeight")); \
+    return FXRbCallIntMethod(this,"getContentHeight"); \
     } \
   FXint cls::getViewportWidth(){ \
-    return FXRbCallIntMethod(this,rb_intern("getViewportWidth")); \
+    return FXRbCallIntMethod(this,"getViewportWidth"); \
     } \
   FXint cls::getViewportHeight(){ \
-    return FXRbCallIntMethod(this,rb_intern("getViewportHeight")); \
+    return FXRbCallIntMethod(this,"getViewportHeight"); \
     }
 
 

data/ext/fox16_c/include/FXRbShutter.h

@@ -57,7 +57,7 @@ inline void klass ## _setCurrent(klass* self,FXint panel){ \
 
 #define IMPLEMENT_FXSHUTTER_STUBS(cls) \
   void cls::setCurrent(FXint panel){ \
-    FXRbCallVoidMethod(this,rb_intern("setCurrent"),panel); \
+    FXRbCallVoidMethod(this,"setCurrent",panel); \
     }
 
 

data/ext/fox16_c/include/FXRbSpinner.h

@@ -35,7 +35,7 @@ inline void klass ## _setValue(klass* self,FXint value,FXbool notify){ \
 
 #define IMPLEMENT_FXSPINNER_STUBS(cls) \
   void cls::setValue(FXint value,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setValue"),value,notify); \
+    FXRbCallVoidMethod(this,"setValue",value,notify); \
     }
 
 

data/ext/fox16_c/include/FXRbStream.h

@@ -41,13 +41,13 @@ inline bool klass ## _position(klass* self,FXlong p,FXWhence whence){ \
 
 #define IMPLEMENT_FXSTREAM_STUBS(cls) \
   bool cls::close(){ \
-    return FXRbCallBoolMethod(this,rb_intern("close")); \
+    return FXRbCallBoolMethod(this,"close"); \
     } \
   bool cls::flush(){ \
-    return FXRbCallBoolMethod(this,rb_intern("flush")); \
+    return FXRbCallBoolMethod(this,"flush"); \
     } \
   bool cls::position(FXlong p,FXWhence whence){ \
-    return FXRbCallBoolMethod(this,rb_intern("setPosition"),p,whence); \
+    return FXRbCallBoolMethod(this,"setPosition",p,whence); \
     }
 
 

data/ext/fox16_c/include/FXRbTabBar.h

@@ -35,7 +35,7 @@ inline void klass ## _setCurrent(klass* self,FXint panel,FXbool notify){ \
 
 #define IMPLEMENT_FXTABBAR_STUBS(cls) \
   void cls::setCurrent(FXint panel,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setCurrent"),panel,notify); \
+    FXRbCallVoidMethod(this,"setCurrent",panel,notify); \
     }
 
 

data/ext/fox16_c/include/FXRbTable.h

@@ -109,91 +109,91 @@ inline void klass ## _destroy(klass* self){ \
 
 #define IMPLEMENT_FXTABLEITEM_STUBS(klass,superklass) \
   void klass::draw(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
-    FXRbCallVoidMethod(this,rb_intern("draw"),table,dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"draw",table,dc,x,y,w,h); \
     } \
   void klass::public_draw(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
     superklass::draw(table,dc,x,y,w,h); \
     } \
   void klass::drawBorders(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
-    FXRbCallVoidMethod(this,rb_intern("drawBorders"),table,dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawBorders",table,dc,x,y,w,h); \
     } \
   void klass::public_drawBorders(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
     superklass::drawBorders(table,dc,x,y,w,h); \
     } \
   void klass::drawContent(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
-    FXRbCallVoidMethod(this,rb_intern("drawContent"),table,dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawContent",table,dc,x,y,w,h); \
     } \
   void klass::public_drawContent(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
     superklass::drawContent(table,dc,x,y,w,h); \
     } \
   void klass::drawPattern(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
-    FXRbCallVoidMethod(this,rb_intern("drawPattern"),table,dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawPattern",table,dc,x,y,w,h); \
     } \
   void klass::public_drawPattern(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
     superklass::drawPattern(table,dc,x,y,w,h); \
     } \
   void klass::drawBackground(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
-    FXRbCallVoidMethod(this,rb_intern("drawBackground"),table,dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawBackground",table,dc,x,y,w,h); \
     } \
   void klass::public_drawBackground(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
     superklass::drawBackground(table,dc,x,y,w,h); \
     } \
   void klass::setText(const FXString& txt){ \
-    FXRbCallVoidMethod(this,rb_intern("setText"),txt); \
+    FXRbCallVoidMethod(this,"setText",txt); \
     } \
   FXString klass::getText() const { \
-    return FXRbCallStringMethod(this,rb_intern("getText")); \
+    return FXRbCallStringMethod(this,"getText"); \
     } \
   void klass::setIcon(FXIcon* icn,FXbool owned){ \
-    FXRbCallVoidMethod(this,rb_intern("setIcon"),icn,owned); \
+    FXRbCallVoidMethod(this,"setIcon",icn,owned); \
     } \
   FXIcon* klass::getIcon() const { \
-    return FXRbCallIconMethod(this,rb_intern("getIcon")); \
+    return FXRbCallIconMethod(this,"getIcon"); \
     } \
   void klass::setFocus(FXbool focus){ \
-    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::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); \
     } \
   void klass::setJustify(FXuint justify){ \
-    FXRbCallVoidMethod(this,rb_intern("setJustify"),justify); \
+    FXRbCallVoidMethod(this,"setJustify",justify); \
     } \
   void klass::setIconPosition(FXuint mode){ \
-    FXRbCallVoidMethod(this,rb_intern("setIconPosition"),mode); \
+    FXRbCallVoidMethod(this,"setIconPosition",mode); \
     } \
   void klass::setBorders(FXuint borders){ \
-    FXRbCallVoidMethod(this,rb_intern("setBorders"),borders); \
+    FXRbCallVoidMethod(this,"setBorders",borders); \
     } \
   void klass::setStipple(FXStipplePattern pattern){ \
-    FXRbCallVoidMethod(this,rb_intern("setStipple"),pattern); \
+    FXRbCallVoidMethod(this,"setStipple",pattern); \
     } \
   FXWindow* klass::getControlFor(FXTable* table){ \
-    return FXRbCallWindowMethod(this,rb_intern("getControlFor"),table); \
+    return FXRbCallWindowMethod(this,"getControlFor",table); \
     } \
   void klass::setFromControl(FXWindow* control){ \
-    FXRbCallVoidMethod(this,rb_intern("setFromControl"),control); \
+    FXRbCallVoidMethod(this,"setFromControl",control); \
     } \
   FXint klass::getWidth(const FXTable* table) const { \
-    return FXRbCallIntMethod(this,rb_intern("getWidth"),table); \
+    return FXRbCallIntMethod(this,"getWidth",table); \
     } \
   FXint klass::getHeight(const FXTable* table) const { \
-    return FXRbCallIntMethod(this,rb_intern("getHeight"),table); \
+    return FXRbCallIntMethod(this,"getHeight",table); \
     } \
   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"); \
     }
 
 
@@ -371,109 +371,109 @@ inline FXbool klass ## _disableItem(klass* self,FXint r,FXint c){ \
 
 #define IMPLEMENT_FXTABLE_STUBS(klass,superklass) \
   void klass::drawCell(FXDC& dc,FXint sr,FXint er,FXint sc,FXint ec){ \
-    FXRbCallVoidMethod(this,rb_intern("drawCell"),dc,sr,er,sc,ec); \
+    FXRbCallVoidMethod(this,"drawCell",dc,sr,er,sc,ec); \
     } \
   void klass::public_drawCell(FXDC& dc,FXint sr,FXint er,FXint sc,FXint ec){ \
     superklass::drawCell(dc,sr,er,sc,ec); \
     } \
   void klass::drawRange(FXDC& dc,FXint rlo,FXint rhi,FXint clo,FXint chi){ \
-    FXRbCallVoidMethod(this,rb_intern("drawRange"),dc,rlo,rhi,clo,chi); \
+    FXRbCallVoidMethod(this,"drawRange",dc,rlo,rhi,clo,chi); \
     } \
   void klass::public_drawRange(FXDC& dc,FXint rlo,FXint rhi,FXint clo,FXint chi){ \
     superklass::drawRange(dc,rlo,rhi,clo,chi); \
     } \
   void klass::drawHGrid(FXDC& dc,FXint rlo,FXint rhi,FXint clo,FXint chi){ \
-    FXRbCallVoidMethod(this,rb_intern("drawHGrid"),dc,rlo,rhi,clo,chi); \
+    FXRbCallVoidMethod(this,"drawHGrid",dc,rlo,rhi,clo,chi); \
     } \
   void klass::public_drawHGrid(FXDC& dc,FXint rlo,FXint rhi,FXint clo,FXint chi){ \
     superklass::drawHGrid(dc,rlo,rhi,clo,chi); \
     } \
   void klass::drawVGrid(FXDC& dc,FXint rlo,FXint rhi,FXint clo,FXint chi){ \
-    FXRbCallVoidMethod(this,rb_intern("drawVGrid"),dc,rlo,rhi,clo,chi); \
+    FXRbCallVoidMethod(this,"drawVGrid",dc,rlo,rhi,clo,chi); \
     } \
   void klass::public_drawVGrid(FXDC& dc,FXint rlo,FXint rhi,FXint clo,FXint chi){ \
     superklass::drawVGrid(dc,rlo,rhi,clo,chi); \
     } \
   void klass::drawContents(FXDC& dc,FXint x,FXint y,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("drawContents"),dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawContents",dc,x,y,w,h); \
     } \
   void klass::public_drawContents(FXDC& dc,FXint x,FXint y,FXint w,FXint h){ \
     superklass::drawContents(dc,x,y,w,h); \
     } \
   FXTableItem* klass::createItem(const FXString& text,FXIcon* icon,void* ptr){ \
-    return FXRbCallTableItemMethod(this,rb_intern("createItem"),text,icon,ptr); \
+    return FXRbCallTableItemMethod(this,"createItem",text,icon,ptr); \
     } \
   FXTableItem* klass::public_createItem(const FXString& text,FXIcon* icon,void* ptr){ \
     return superklass::createItem(text,icon,ptr); \
     } \
   void klass::setTableSize(FXint nr,FXint nc,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setTableSize"),nr,nc,notify); \
+    FXRbCallVoidMethod(this,"setTableSize",nr,nc,notify); \
     } \
   void klass::insertRows(FXint row,FXint nr,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("insertRows"),row,nr,notify); \
+    FXRbCallVoidMethod(this,"insertRows",row,nr,notify); \
     } \
   void klass::insertColumns(FXint col,FXint nc,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("insertColumns"),col,nc,notify); \
+    FXRbCallVoidMethod(this,"insertColumns",col,nc,notify); \
     } \
   void klass::removeRows(FXint row,FXint nr,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("removeRows"),row,nr,notify); \
+    FXRbCallVoidMethod(this,"removeRows",row,nr,notify); \
     } \
   void klass::removeColumns(FXint col,FXint nc,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("removeColumns"),col,nc,notify); \
+    FXRbCallVoidMethod(this,"removeColumns",col,nc,notify); \
     } \
   FXTableItem* klass::extractItem(FXint row,FXint col,FXbool notify){ \
-    return FXRbCallTableItemMethod(this,rb_intern("extractItem"),row,col,notify); \
+    return FXRbCallTableItemMethod(this,"extractItem",row,col,notify); \
     } \
   void klass::removeItem(FXint row,FXint col,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("removeItem"),row,col,notify); \
+    FXRbCallVoidMethod(this,"removeItem",row,col,notify); \
     } \
   void klass::removeRange(FXint startrow,FXint startcol,FXint endrow,FXint endcol,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("removeRange"),startrow,startcol,endrow,endcol,notify); \
+    FXRbCallVoidMethod(this,"removeRange",startrow,startcol,endrow,endcol,notify); \
     } \
   void klass::clearItems(FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("clearItems"),notify); \
+    FXRbCallVoidMethod(this,"clearItems",notify); \
     } \
   void klass::setColumnWidth(FXint col,FXint cwidth){ \
-    FXRbCallVoidMethod(this,rb_intern("setColumnWidth"),col,cwidth); \
+    FXRbCallVoidMethod(this,"setColumnWidth",col,cwidth); \
     } \
   void klass::setRowHeight(FXint row,FXint rheight){ \
-    FXRbCallVoidMethod(this,rb_intern("setRowHeight"),row,rheight); \
+    FXRbCallVoidMethod(this,"setRowHeight",row,rheight); \
     } \
   void klass::setCurrentItem(FXint r,FXint c,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("setCurrentItem"),r,c,notify); \
+    FXRbCallVoidMethod(this,"setCurrentItem",r,c,notify); \
     } \
   FXbool klass::selectRow(FXint row,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("selectRow"),row,notify); \
+    return FXRbCallBoolMethod(this,"selectRow",row,notify); \
     } \
   FXbool klass::selectColumn(FXint col,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("selectColumn"),col,notify); \
+    return FXRbCallBoolMethod(this,"selectColumn",col,notify); \
     } \
   FXbool klass::selectRange(FXint sr,FXint er,FXint sc,FXint ec,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("selectRange"),sr,er,sc,ec,notify); \
+    return FXRbCallBoolMethod(this,"selectRange",sr,er,sc,ec,notify); \
     } \
   FXbool klass::extendSelection(FXint r,FXint c,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("extendSelection"),r,c,notify); \
+    return FXRbCallBoolMethod(this,"extendSelection",r,c,notify); \
     } \
   FXbool klass::killSelection(FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("killSelection"),notify); \
+    return FXRbCallBoolMethod(this,"killSelection",notify); \
     } \
   void klass::startInput(FXint row,FXint col){ \
-    FXRbCallVoidMethod(this,rb_intern("startInput"),row,col); \
+    FXRbCallVoidMethod(this,"startInput",row,col); \
     } \
   void klass::cancelInput(){ \
-    FXRbCallVoidMethod(this,rb_intern("cancelInput")); \
+    FXRbCallVoidMethod(this,"cancelInput"); \
     } \
   void klass::acceptInput(FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("acceptInput"),notify); \
+    FXRbCallVoidMethod(this,"acceptInput",notify); \
     } \
   void klass::makePositionVisible(FXint r,FXint c){ \
-    FXRbCallVoidMethod(this,rb_intern("makePositionVisible"),r,c); \
+    FXRbCallVoidMethod(this,"makePositionVisible",r,c); \
     } \
   FXbool klass::enableItem(FXint r,FXint c){ \
-    return FXRbCallBoolMethod(this,rb_intern("enableItem"),r,c); \
+    return FXRbCallBoolMethod(this,"enableItem",r,c); \
     } \
   FXbool klass::disableItem(FXint r,FXint c){ \
-    return FXRbCallBoolMethod(this,rb_intern("disableItem"),r,c); \
+    return FXRbCallBoolMethod(this,"disableItem",r,c); \
     }
 
 class FXRbTable : public FXTable {