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

data/ext/fox16_c/extconf.rb

@@ -7,7 +7,7 @@ def find_installed_fox_version
   stddirs = ["/usr/include/fox-1.6",
              "/usr/local/include/fox-1.6",
              "/sw/include/fox-1.6",
-	     "/opt/local/include/fox-1.6"]
+            "/opt/local/include/fox-1.6"]
   usrdirs = []
   ARGV.each do |arg|
     if arg =~ /--with-fox-include/
@@ -109,12 +109,13 @@ def do_rake_compiler_setup
 
     dir_config("installed")
 
+    host = RbConfig::CONFIG["host_alias"].empty? ? RbConfig::CONFIG["host"] : RbConfig::CONFIG["host_alias"]
     libz_recipe = MiniPortile.new("libz", LIBZ_VERSION).tap do |recipe|
       recipe.files = [LIBZ_SOURCE_URI]
       recipe.target = portsdir = File.expand_path('../../../ports', __FILE__)
       # Prefer host_alias over host in order to use i586-mingw32msvc as
       # correct compiler prefix for cross build, but use host if not set.
-      recipe.host = RbConfig::CONFIG["host_alias"].empty? ? RbConfig::CONFIG["host"] : RbConfig::CONFIG["host_alias"]
+      recipe.host = host
       class << recipe
         def configure
           Dir.chdir work_path do
@@ -157,7 +158,7 @@ def do_rake_compiler_setup
       recipe.target = portsdir = File.expand_path('../../../ports', __FILE__)
       # Prefer host_alias over host in order to use i586-mingw32msvc as
       # correct compiler prefix for cross build, but use host if not set.
-      recipe.host = RbConfig::CONFIG["host_alias"].empty? ? RbConfig::CONFIG["host"] : RbConfig::CONFIG["host_alias"]
+      recipe.host = host
       recipe.configure_options = [
         "--host=#{recipe.host}",
         "--enable-shared",
@@ -182,7 +183,7 @@ def do_rake_compiler_setup
       recipe.target = portsdir = File.expand_path('../../../ports', __FILE__)
       # Prefer host_alias over host in order to use i586-mingw32msvc as
       # correct compiler prefix for cross build, but use host if not set.
-      recipe.host = RbConfig::CONFIG["host_alias"].empty? ? RbConfig::CONFIG["host"] : RbConfig::CONFIG["host_alias"]
+      recipe.host = host
       recipe.configure_options = [
         "--host=#{recipe.host}",
         "--enable-shared",
@@ -202,7 +203,7 @@ def do_rake_compiler_setup
       recipe.target = portsdir = File.expand_path('../../../ports', __FILE__)
       # Prefer host_alias over host in order to use i586-mingw32msvc as
       # correct compiler prefix for cross build, but use host if not set.
-      recipe.host = RbConfig::CONFIG["host_alias"].empty? ? RbConfig::CONFIG["host"] : RbConfig::CONFIG["host_alias"]
+      recipe.host = host
       recipe.configure_options = [
         "--host=#{recipe.host}",
         "--enable-shared",
@@ -222,7 +223,7 @@ def do_rake_compiler_setup
       recipe.target = portsdir = File.expand_path('../../../ports', __FILE__)
       # Prefer host_alias over host in order to use i586-mingw32msvc as
       # correct compiler prefix for cross build, but use host if not set.
-      recipe.host = RbConfig::CONFIG["host_alias"].empty? ? RbConfig::CONFIG["host"] : RbConfig::CONFIG["host_alias"]
+      recipe.host = host
       recipe.configure_options = [
         "--host=#{recipe.host}",
         "--without-xft",
@@ -255,7 +256,7 @@ def do_rake_compiler_setup
       recipe.target = portsdir = File.expand_path('../../../ports', __FILE__)
       # Prefer host_alias over host in order to use i586-mingw32msvc as
       # correct compiler prefix for cross build, but use host if not set.
-      recipe.host = RbConfig::CONFIG["host_alias"].empty? ? RbConfig::CONFIG["host"] : RbConfig::CONFIG["host_alias"]
+      recipe.host = host
       recipe.configure_options = [
         "--host=#{recipe.host}",
         "--enable-shared",
@@ -282,22 +283,19 @@ def do_rake_compiler_setup
 
       checkpoint = File.join(portsdir, "#{recipe.name}-#{recipe.version}-#{recipe.host}.installed")
       unless File.exist?(checkpoint)
-        recipe.cook
-        FileUtils.touch checkpoint
+        with_env(
+          'PKG_CONFIG_PATH' => "#{libfox_recipe.path}/lib/pkgconfig"
+        ) do
+          recipe.cook
+          FileUtils.touch checkpoint
+        end
       end
       recipe.activate
     end
+    $autodetected_fxscintilla = true
 
-#     have_library( 'gdi32', 'CreateDC' ) && append_library( $libs, 'gdi32' )
-#     have_library( 'opengl32' ) && append_library( $libs, 'opengl32' )
-#     have_library( 'winspool', 'EnumPrintersA') && append_library( $libs, 'winspool' )
-
-#     dir_config('libz', "#{libz_recipe.path}/include", "#{libz_recipe.path}/lib")
-#     dir_config('libpng', "#{libpng_recipe.path}/include", "#{libpng_recipe.path}/lib")
-#     dir_config('libtiff', "#{libtiff_recipe.path}/include", "#{libtiff_recipe.path}/lib")
-#     dir_config('libjpeg', "#{libjpeg_recipe.path}/include", "#{libjpeg_recipe.path}/lib")
-    dir_config('libfox', "#{libfox_recipe.path}/include", "#{libfox_recipe.path}/lib")
-    dir_config('libfxscintilla', "#{libfxscintills_recipe.path}/include", "#{libfxscintills_recipe.path}/lib")
+    dir_config('libfox', "#{libfox_recipe.path}/include/fox-1.6", "#{libfox_recipe.path}/lib")
+    dir_config('libfxscintilla', "#{libfxscintills_recipe.path}/include/fxscintilla", "#{libfxscintills_recipe.path}/lib")
 
     shared_dlls = [
         "#{libfxscintills_recipe.path}/bin/libfxscintilla-20.dll",
@@ -320,7 +318,7 @@ def do_rake_compiler_setup
       FileUtils.cp `#{cmd}`.chomp, '.', verbose: true
     end
 
-    CONFIG['CXX'] = "#{RbConfig::CONFIG["host"]}-g++" # CXX setting must be prefixed for cross build
+    CONFIG['CXX'] = "#{host}-g++" # CXX setting must be prefixed for cross build
     CONFIG['CC'] += "\nCXX=#{CONFIG['CXX']}" # Hack CXX into Makefile for cross compilation
     CONFIG['LDSHARED'].gsub!('gcc', 'g++') # ensure C++ linker is used, so that libstdc++ is linked static
     $LDFLAGS += " -s" # remove symbol table informations from shared lib
@@ -350,8 +348,8 @@ def do_rake_compiler_setup
   find_library("GLU", "gluNewQuadric", "/usr/X11R6/lib")
   $libs = append_library($libs, "Xrandr") unless RUBY_PLATFORM =~ /mingw/ || enable_config("win32-static-build")
   $libs = append_library($libs, "Xcursor") unless RUBY_PLATFORM =~ /mingw/ || enable_config("win32-static-build")
-  find_header('FXRbCommon.h', File.join(File.dirname(__FILE__), 'include'))
   $libs = append_library($libs, "FOX-1.6")
+  $INCFLAGS << " -I#{File.join(File.dirname(__FILE__), 'include')}"
   if is_fxscintilla_build?
     FileUtils.move('scintilla_wrap.cpp.bak', 'scintilla_wrap.cpp') if FileTest.exist?('scintilla_wrap.cpp.bak')
     $CPPFLAGS = $CPPFLAGS + " -DWITH_FXSCINTILLA -DHAVE_FOX_1_6"
@@ -359,6 +357,13 @@ def do_rake_compiler_setup
   else
     FileUtils.move('scintilla_wrap.cpp', 'scintilla_wrap.cpp.bak') if FileTest.exist?('scintilla_wrap.cpp')
   end
+
+  checking_for("thread local variables") do
+    $defs.push( "-DHAVE___THREAD" ) if try_compile('__thread int x=1;')
+  end &&
+      have_func('rb_thread_call_without_gvl') &&
+      have_func('rb_thread_call_with_gvl')
+
 end
 
 # This directive processes the "--with-fox-include" and "--with-fox-lib"
@@ -372,15 +377,17 @@ dir_config('fox', '/usr/local/include/fox-1.6', '/usr/local/lib')
 
 dir_config('fxscintilla', '/usr/local/include/fxscintilla', '/usr/local/lib')
 
-find_installed_fox_version
+unless enable_config("win32-cross")
+  find_installed_fox_version
 
-#
-# Check for FXScintilla header files, unless FXScintilla support has
-# been explicitly suppressed with the '--without-fxscintilla' flag.
-#
+  #
+  # Check for FXScintilla header files, unless FXScintilla support has
+  # been explicitly suppressed with the '--without-fxscintilla' flag.
+  #
 
-unless fxscintilla_support_suppressed?
-  find_installed_fxscintilla_version
+  unless fxscintilla_support_suppressed?
+    find_installed_fxscintilla_version
+  end
 end
 
 # Platform-specific modifications
@@ -391,4 +398,5 @@ $CFLAGS += " -DRUBY_1_9" if RUBY_VERSION =~ /1\.9\./
 $CFLAGS += " -DRUBY_2_0" if RUBY_VERSION =~ /2\.0\./
 
 # Last step: build the makefile
+create_header
 create_makefile("fox16_c")

data/ext/fox16_c/gvl_wrappers.cpp

@@ -0,0 +1,12 @@
+/*
+ * gvl_wrappers.c - Wrapper functions for locking/unlocking the Ruby GVL
+ *
+ */
+
+#include "FXRbCommon.h"
+
+__thread int g_fxrb_thread_has_gvl = 1;
+
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_SKELETON );
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB );

data/ext/fox16_c/include/FXRbApp.h

@@ -38,6 +38,33 @@ inline void cls ## _detach(cls *self){ \
 inline void cls ## _create(cls *self){ \
   self->cls::create(); \
   } \
+inline FXint cls ## _run_gvl(cls *self){ \
+  return self->cls::run(); \
+  } \
+inline FXint cls ## _runOneEvent_gvl(cls *self, bool blocking=true){ \
+  return self->cls::runOneEvent(blocking); \
+  } \
+inline FXint cls ## _runUntil_gvl(cls *self, FXuint& condition){ \
+  return self->cls::runUntil(condition); \
+  } \
+inline FXint cls ## _runWhileEvents_gvl(cls *self){ \
+  return self->cls::runWhileEvents(); \
+  } \
+inline FXint cls ## _runModalWhileEvents_gvl(cls *self, FXWindow* window=NULL){ \
+  return self->cls::runModalWhileEvents(window); \
+  } \
+inline FXint cls ## _runModal_gvl(cls *self){ \
+  return self->cls::runModal(); \
+  } \
+inline FXint cls ## _runModalFor_gvl(cls *self, FXWindow* window){ \
+  return self->cls::runModalFor(window); \
+  } \
+inline FXint cls ## _runModalWhileShown_gvl(cls *self, FXWindow* window){ \
+  return self->cls::runModalWhileShown(window); \
+  } \
+inline FXint cls ## _runPopup_gvl(cls *self, FXWindow* owner){ \
+  return self->cls::runPopup(owner); \
+  } \
 static void cls ## _init(cls* self,VALUE ary,bool connect){ \
   int i; \
   char **argv; \
@@ -62,7 +89,6 @@ inline void cls ## _exit(cls *self,FXint code){ \
   self->cls::exit(code); \
   }
 
-
 /**
  * For C/C++ applications, the argument count (argc) will always be at least
  * one, and the first element of the argument array (argv[0]) will contain
@@ -83,13 +109,13 @@ inline void cls ## _exit(cls *self,FXint code){ \
  */
 #define IMPLEMENT_FXAPP_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::init(int& argc,char** argv,bool connect){ \
     int i; \
@@ -97,7 +123,7 @@ inline void cls ## _exit(cls *self,FXint code){ \
     for(i=1; i<argc; i++){ \
       rb_ary_push(ary,rb_str_new2(argv[i])); \
       } \
-    FXRbCallVoidMethod(this,rb_intern("init"),ary,connect); \
+    FXRbCallVoidMethod(this,"init",ary,connect); \
     argc=static_cast<int>(RARRAY_LEN(ary)+1); \
     for(i=1; i<argc; i++){ \
       VALUE e=rb_ary_entry(ary,i-1); \
@@ -105,7 +131,7 @@ inline void cls ## _exit(cls *self,FXint code){ \
       } \
     } \
   void cls::exit(FXint code){ \
-    FXRbCallVoidMethod(this,rb_intern("exit"),code); \
+    FXRbCallVoidMethod(this,"exit",code); \
     }
 
 
@@ -114,6 +140,12 @@ class FXRbApp : public FXApp {
 protected:
   FXbool m_bThreadsEnabled;
   FXuint sleepTime;
+public:
+#ifdef WIN32
+  static WSAEVENT interrupt_event;
+#else
+  static int interrupt_fds[2];
+#endif
 protected:
   FXRbApp(){}
 public:
@@ -126,6 +158,7 @@ public:
     };
 public:
   long onChoreThreads(FXObject*,FXSelector,void*);
+  long onChoreThreads_gvlcb(FXObject*,FXSelector,void*);
 public:
   // Constructor
   FXRbApp(const FXchar* name,const FXchar* vendor);
@@ -152,4 +185,6 @@ public:
   virtual ~FXRbApp();
   };
 
+long FXRbApp_onChoreThreads_gvlcb(FXRbApp*,FXObject*,FXSelector,void*);
+
 #endif

data/ext/fox16_c/include/FXRbBitmap.h

@@ -68,40 +68,40 @@ inline void cls ## _setData(cls* self,FXuchar* pix,FXuint opts,FXint w,FXint h){
 
 #define IMPLEMENT_FXBITMAP_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"); \
     } \
   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); \
     } \
   void cls::scale(FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("scale"),w,h); \
+    FXRbCallVoidMethod(this,"scale",w,h); \
     } \
   void cls::mirror(FXbool horizontal,FXbool 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,FXbool color){ \
-    FXRbCallVoidMethod(this,rb_intern("crop"),x,y,w,h,color); \
+    FXRbCallVoidMethod(this,"crop",x,y,w,h,color); \
     } \
   void cls::fill(FXbool color){ \
-    FXRbCallVoidMethod(this,rb_intern("fill"),color); \
+    FXRbCallVoidMethod(this,"fill",color); \
     } \
   void cls::setData(FXuchar* pix,FXuint opts){ \
-    FXRbCallVoidMethod(this,rb_intern("setData"),pix,opts); \
+    FXRbCallVoidMethod(this,"setData",pix,opts); \
     } \
   void cls::setData(FXuchar* pix,FXuint opts,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("setData"),pix,opts,w,h); \
+    FXRbCallVoidMethod(this,"setData",pix,opts,w,h); \
     }
 
 

data/ext/fox16_c/include/FXRbCommon.h

@@ -27,6 +27,8 @@
 extern "C" {
 #include "ruby.h"
 
+#include "extconf.h"
+
 #ifdef HAVE_RUBY_ENCODING_H
 #include "ruby/encoding.h"
 #endif
@@ -97,3 +99,4 @@ extern "C" {
 #include "FXScintilla.h"
 #endif
 #include "FXRuby.h"
+#include "gvl_wrappers.h"

data/ext/fox16_c/include/FXRbCursor.h

@@ -38,10 +38,10 @@ inline bool klass ## _loadPixels(klass* self,FXStream& store){ \
 
 #define IMPLEMENT_FXCURSOR_STUBS(cls) \
   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); \
     }
 
 class FXRbCursor : public FXCursor {

data/ext/fox16_c/include/FXRbDC.h

@@ -218,190 +218,190 @@ inline void klass ## _clipChildren(klass* self,FXbool yes){ \
 
 #define IMPLEMENT_FXDC_STUBS(cls) \
   FXColor cls::readPixel(FXint x,FXint y){ \
-    return FXRbCallColorMethod(this,rb_intern("readPixel"),x,y); \
+    return FXRbCallColorMethod(this,"readPixel",x,y); \
     } \
   void cls::drawPoint(FXint x,FXint y){ \
-    FXRbCallVoidMethod(this,rb_intern("drawPoint"),x,y); \
+    FXRbCallVoidMethod(this,"drawPoint",x,y); \
     } \
   void cls::drawPoints(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawPoints"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"drawPoints",points,npoints); \
     } \
   void cls::drawPointsRel(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawPointsRel"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"drawPointsRel",points,npoints); \
     } \
   void cls::drawLine(FXint x1,FXint y1,FXint x2,FXint y2){ \
-    FXRbCallVoidMethod(this,rb_intern("drawLine"),x1,y1,x2,y2); \
+    FXRbCallVoidMethod(this,"drawLine",x1,y1,x2,y2); \
     } \
   void cls::drawLines(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawLines"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"drawLines",points,npoints); \
     } \
   void cls::drawLinesRel(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawLinesRel"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"drawLinesRel",points,npoints); \
     } \
   void cls::drawLineSegments(const FXSegment* segments,FXuint nsegments){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawLineSegments"),1,FXRbMakeArray(segments,nsegments)); \
+    FXRbCallVoidArrayMethod(this,"drawLineSegments",segments,nsegments); \
     } \
   void cls::drawRectangle(FXint x,FXint y,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("drawRectangle"),x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawRectangle",x,y,w,h); \
     } \
   void cls::drawRoundRectangle(FXint x,FXint y,FXint w,FXint h,FXint ew,FXint eh){ \
-    FXRbCallVoidMethod(this,rb_intern("drawRoundRectangle"),x,y,w,h,ew,eh); \
+    FXRbCallVoidMethod(this,"drawRoundRectangle",x,y,w,h,ew,eh); \
     } \
   void cls::drawRectangles(const FXRectangle* rectangles,FXuint nrectangles){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawRectangles"),1,FXRbMakeArray(rectangles,nrectangles)); \
+    FXRbCallVoidArrayMethod(this,"drawRectangles",rectangles,nrectangles); \
     } \
   void cls::drawArc(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2){ \
-    FXRbCallVoidMethod(this,rb_intern("drawArc"),x,y,w,h,ang1,ang2); \
+    FXRbCallVoidMethod(this,"drawArc",x,y,w,h,ang1,ang2); \
     } \
   void cls::drawArcs(const FXArc* arcs,FXuint narcs){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawArcs"),1,FXRbMakeArray(arcs,narcs)); \
+    FXRbCallVoidArrayMethod(this,"drawArcs",arcs,narcs); \
     } \
   void cls::drawEllipse(FXint x,FXint y,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("drawEllipse"),x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawEllipse",x,y,w,h); \
     } \
   void cls::fillRectangle(FXint x,FXint y,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("fillRectangle"),x,y,w,h); \
+    FXRbCallVoidMethod(this,"fillRectangle",x,y,w,h); \
     } \
   void cls::fillRectangles(const FXRectangle* rectangles,FXuint nrectangles){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("fillRectangles"),1,FXRbMakeArray(rectangles,nrectangles)); \
+    FXRbCallVoidArrayMethod(this,"fillRectangles",rectangles,nrectangles); \
     } \
   void cls::fillRoundRectangle(FXint x,FXint y,FXint w,FXint h,FXint ew,FXint eh){ \
-    FXRbCallVoidMethod(this,rb_intern("fillRoundRectangle"),x,y,w,h,ew,eh); \
+    FXRbCallVoidMethod(this,"fillRoundRectangle",x,y,w,h,ew,eh); \
     } \
   void cls::fillChord(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2){ \
-    FXRbCallVoidMethod(this,rb_intern("fillChord"),x,y,w,h,ang1,ang2); \
+    FXRbCallVoidMethod(this,"fillChord",x,y,w,h,ang1,ang2); \
     } \
   void cls::fillChords(const FXArc* chords,FXuint nchords){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("fillChords"),1,FXRbMakeArray(chords,nchords)); \
+    FXRbCallVoidArrayMethod(this,"fillChords",chords,nchords); \
     } \
   void cls::fillArc(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2){ \
-    FXRbCallVoidMethod(this,rb_intern("fillArc"),x,y,w,h,ang1,ang2); \
+    FXRbCallVoidMethod(this,"fillArc",x,y,w,h,ang1,ang2); \
     } \
   void cls::fillArcs(const FXArc* arcs,FXuint narcs){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("fillArcs"),1,FXRbMakeArray(arcs,narcs)); \
+    FXRbCallVoidArrayMethod(this,"fillArcs",arcs,narcs); \
     } \
   void cls::fillEllipse(FXint x,FXint y,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("fillEllipse"),x,y,w,h); \
+    FXRbCallVoidMethod(this,"fillEllipse",x,y,w,h); \
     } \
   void cls::fillPolygon(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("fillPolygon"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"fillPolygon",points,npoints); \
     } \
   void cls::fillConcavePolygon(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("fillConcavePolygon"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"fillConcavePolygon",points,npoints); \
     } \
   void cls::fillComplexPolygon(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("fillComplexPolygon"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"fillComplexPolygon",points,npoints); \
     } \
   void cls::fillPolygonRel(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("fillPolygonRel"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"fillPolygonRel",points,npoints); \
     } \
   void cls::fillConcavePolygonRel(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("fillConcavePolygonRel"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"fillConcavePolygonRel",points,npoints); \
     } \
   void cls::fillComplexPolygonRel(const FXPoint* points,FXuint npoints){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("fillComplexPolygonRel"),1,FXRbMakeArray(points,npoints)); \
+    FXRbCallVoidArrayMethod(this,"fillComplexPolygonRel",points,npoints); \
     } \
   void cls::drawHashBox(FXint x,FXint y,FXint w,FXint h,FXint b){ \
-    FXRbCallVoidMethod(this,rb_intern("drawHashBox"),x,y,w,h,b); \
+    FXRbCallVoidMethod(this,"drawHashBox",x,y,w,h,b); \
     } \
   void cls::drawFocusRectangle(FXint x,FXint y,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("drawFocusRectangle"),x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawFocusRectangle",x,y,w,h); \
     } \
   void cls::drawArea(const FXDrawable* source,FXint sx,FXint sy,FXint sw,FXint sh,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("drawArea"),source,sx,sy,sw,sh,dx,dy); \
+    FXRbCallVoidMethod(this,"drawArea",source,sx,sy,sw,sh,dx,dy); \
     } \
   void cls::drawArea(const FXDrawable* source,FXint sx,FXint sy,FXint sw,FXint sh,FXint dx,FXint dy,FXint dw,FXint dh){ \
-    FXRbCallVoidMethod(this,rb_intern("drawArea"),source,sx,sy,sw,sh,dx,dy,dw,dh); \
+    FXRbCallVoidMethod(this,"drawArea",source,sx,sy,sw,sh,dx,dy,dw,dh); \
     } \
   void cls::drawImage(const FXImage* image,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("drawImage"),image,dx,dy); \
+    FXRbCallVoidMethod(this,"drawImage",image,dx,dy); \
     } \
   void cls::drawBitmap(const FXBitmap* bitmap,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("drawBitmap"),bitmap,dx,dy); \
+    FXRbCallVoidMethod(this,"drawBitmap",bitmap,dx,dy); \
     } \
   void cls::drawIcon(const FXIcon* icon,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("drawIcon"),icon,dx,dy); \
+    FXRbCallVoidMethod(this,"drawIcon",icon,dx,dy); \
     } \
   void cls::drawIconShaded(const FXIcon* icon,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("drawIconShaded"),icon,dx,dy); \
+    FXRbCallVoidMethod(this,"drawIconShaded",icon,dx,dy); \
     } \
   void cls::drawIconSunken(const FXIcon* icon,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("drawIconSunken"),icon,dx,dy); \
+    FXRbCallVoidMethod(this,"drawIconSunken",icon,dx,dy); \
     } \
   void cls::drawText(FXint x,FXint y,const FXString& string){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawText"),3,to_ruby(x),to_ruby(y),to_ruby(string)); \
+    FXRbCallDCDrawMethod(this, "drawText", x, y, string); \
     } \
   void cls::drawText(FXint x,FXint y,const FXchar* string,FXuint length){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawText"),3,to_ruby(x),to_ruby(y),to_ruby(string,length)); \
+    FXRbCallDCDrawMethod(this, "drawText", x, y, string, length); \
     } \
   void cls::drawImageText(FXint x,FXint y,const FXString& string){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawImageText"),3,to_ruby(x),to_ruby(y),to_ruby(string)); \
+    FXRbCallDCDrawMethod(this, "drawImageText", x, y, string); \
     } \
   void cls::drawImageText(FXint x,FXint y,const FXchar* string,FXuint length){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("drawImageText"),3,to_ruby(x),to_ruby(y),to_ruby(string,length)); \
+    FXRbCallDCDrawMethod(this, "drawImageText", x, y, string, length); \
     } \
   void cls::setForeground(FXColor clr){ \
-    FXRbCallVoidMethod(this,rb_intern("setForeground"),clr); \
+    FXRbCallVoidMethod(this,"setForeground",clr); \
     } \
   void cls::setBackground(FXColor clr){ \
-    FXRbCallVoidMethod(this,rb_intern("setBackground"),clr); \
+    FXRbCallVoidMethod(this,"setBackground",clr); \
     } \
   void cls::setDashes(FXuint dashoffset,const FXchar *dashpattern,FXuint dashlength){ \
-    rb_funcall(FXRbGetRubyObj(this,false),rb_intern("setDashes"),2,to_ruby(dashoffset),FXRbMakeArray(dashpattern,dashlength)); \
+    FXRbCallSetDashes(this,"setDashes",dashoffset,dashpattern,dashlength); \
     } \
   void cls::setLineWidth(FXuint linewidth){ \
-    FXRbCallVoidMethod(this,rb_intern("setLineWidth"),linewidth); \
+    FXRbCallVoidMethod(this,"setLineWidth",linewidth); \
     } \
   void cls::setLineCap(FXCapStyle capstyle){ \
-    FXRbCallVoidMethod(this,rb_intern("setLineCap"),capstyle); \
+    FXRbCallVoidMethod(this,"setLineCap",capstyle); \
     } \
   void cls::setLineJoin(FXJoinStyle joinstyle){ \
-    FXRbCallVoidMethod(this,rb_intern("setLineJoin"),joinstyle); \
+    FXRbCallVoidMethod(this,"setLineJoin",joinstyle); \
     } \
   void cls::setLineStyle(FXLineStyle linestyle){ \
-    FXRbCallVoidMethod(this,rb_intern("setLineStyle"),linestyle); \
+    FXRbCallVoidMethod(this,"setLineStyle",linestyle); \
     } \
   void cls::setFillStyle(FXFillStyle fillstyle){ \
-    FXRbCallVoidMethod(this,rb_intern("setFillStyle"),fillstyle); \
+    FXRbCallVoidMethod(this,"setFillStyle",fillstyle); \
     } \
   void cls::setFillRule(FXFillRule fillrule){ \
-    FXRbCallVoidMethod(this,rb_intern("setFillRule"),fillrule); \
+    FXRbCallVoidMethod(this,"setFillRule",fillrule); \
     } \
   void cls::setFunction(FXFunction func){ \
-    FXRbCallVoidMethod(this,rb_intern("setFunction"),func); \
+    FXRbCallVoidMethod(this,"setFunction",func); \
     } \
   void cls::setTile(FXImage* image,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("setTile"),image,dx,dy); \
+    FXRbCallVoidMethod(this,"setTile",image,dx,dy); \
     } \
   void cls::setStipple(FXBitmap *bitmap,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("setStipple"),bitmap,dx,dy); \
+    FXRbCallVoidMethod(this,"setStipple",bitmap,dx,dy); \
     } \
   void cls::setStipple(FXStipplePattern pat,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("setStipple"),pat,dx,dy); \
+    FXRbCallVoidMethod(this,"setStipple",pat,dx,dy); \
     } \
   void cls::setClipRegion(const FXRegion& region){ \
-    FXRbCallVoidMethod(this,rb_intern("setClipRegion"),region); \
+    FXRbCallVoidMethod(this,"setClipRegion",region); \
     } \
   void cls::setClipRectangle(FXint x,FXint y,FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("setClipRectangle"),x,y,w,h); \
+    FXRbCallVoidMethod(this,"setClipRectangle",x,y,w,h); \
     } \
   void cls::setClipRectangle(const FXRectangle& rectangle){ \
-    FXRbCallVoidMethod(this,rb_intern("setClipRectangle"),rectangle); \
+    FXRbCallVoidMethod(this,"setClipRectangle",rectangle); \
     } \
   void cls::clearClipRectangle(){ \
-    FXRbCallVoidMethod(this,rb_intern("clearClipRectangle")); \
+    FXRbCallVoidMethod(this,"clearClipRectangle"); \
     } \
   void cls::setClipMask(FXBitmap* bitmap,FXint dx,FXint dy){ \
-    FXRbCallVoidMethod(this,rb_intern("setClipMask"),bitmap,dx,dy); \
+    FXRbCallVoidMethod(this,"setClipMask",bitmap,dx,dy); \
     } \
   void cls::clearClipMask(){ \
-    FXRbCallVoidMethod(this,rb_intern("clearClipMask")); \
+    FXRbCallVoidMethod(this,"clearClipMask"); \
     } \
   void cls::setFont(FXFont *fnt){ \
-    FXRbCallVoidMethod(this,rb_intern("setFont"),fnt); \
+    FXRbCallVoidMethod(this,"setFont",fnt); \
     } \
   void cls::clipChildren(FXbool yes){ \
-    FXRbCallVoidMethod(this,rb_intern("clipChildren"),yes); \
+    FXRbCallVoidMethod(this,"clipChildren",yes); \
     }